version-control/the-stack-ds-lib-100k · Datasets at Hugging Face

repo_name stringlengths 6 130	hexsha list	file_path list	code list	apis list
nicolay-r/attitude-extraction-with-attention-and-ds	[ "fb8e9d0d9488363738a88c4c447c7a8cb3e2ec1d" ]	[ "rusentrel/classic/ctx/att_hidden_z_yang.py" ]	[ "#!/usr/bin/python\n# -- coding: utf-8 --\nimport sys\nimport tensorflow as tf\n\n\nsys.path.append('../../../')\n\nfrom io_utils import RuSentRelBasedExperimentsIOUtils\nfrom arekit.contrib.networks.context.architectures.att_self_z_yang_bilstm import AttentionSelfZYangBiLSTM\nfrom arekit.contrib.networks.context.configurations.att_self_z_yang_bilstm import AttentionSelfZYangBiLSTMConfig\nfrom arekit.common.evaluation.evaluators.two_class import TwoClassEvaluator\nfrom arekit.contrib.experiments.nn_io.rusentrel import RuSentRelBasedNeuralNetworkIO\nfrom arekit.contrib.experiments.single.model import SingleInstanceTensorflowModel\n\nfrom rusentrel.ctx_names import ModelNames\nfrom arekit.contrib.experiments.engine import run_testing\nfrom arekit.contrib.experiments.callback import CustomCallback\n\nfrom rusentrel.classic.common import \\\n classic_ctx_common_config_settings, \\\n classic_common_callback_modification_func\n\n\ndef ctx_att_hidden_zyang_bilstm_custom_config(config):\n assert(isinstance(config, AttentionSelfZYangBiLSTMConfig))\n config.modify_bags_per_minibatch(2)\n config.modify_weight_initializer(tf.contrib.layers.xavier_initializer())\n\n\ndef run_testing_att_hidden_zyang_bilstm(name_prefix=u'',\n cv_count=1,\n custom_config_func=ctx_att_hidden_zyang_bilstm_custom_config,\n custom_callback_func=classic_common_callback_modification_func):\n\n run_testing(full_model_name=name_prefix + ModelNames().AttSelfZYangBiLSTM,\n create_network=AttentionSelfZYangBiLSTM,\n create_config=AttentionSelfZYangBiLSTMConfig,\n create_nn_io=RuSentRelBasedNeuralNetworkIO,\n cv_count=cv_count,\n create_model=SingleInstanceTensorflowModel,\n evaluator_class=TwoClassEvaluator,\n create_callback=CustomCallback,\n experiments_io=RuSentRelBasedExperimentsIOUtils(),\n common_callback_modification_func=custom_callback_func,\n custom_config_modification_func=custom_config_func,\n common_config_modification_func=classic_ctx_common_config_settings)\n\n\nif __name__ == \"__main__\":\n\n run_testing_att_hidden_zyang_bilstm()\n" ]	[ [ "tensorflow.contrib.layers.xavier_initializer" ] ]
mvpmanish/LASED	[ "7793037b3e77ee9205f631d7ff6c511895108400" ]	[ "base-LASED/build/lib/LASED/time_evolution_matrix.py" ]	[ "'''\nThis is a file to define a function to populate the time evolution matrix for a laser-atom system\nAuthor: Manish Patel\nDate created: 12/05/2021\n'''\n\nfrom LASED.state import \nfrom LASED.detuning import \nfrom LASED.symbolic_print import \nfrom LASED.half_rabi_freq import \nfrom LASED.decay_constant import \nfrom LASED.index import \n\nfrom sympy import \nfrom sympy import Symbol\nimport numpy as np\n\ndef timeEvolutionMatrix(n, E, G, Q, Q_decay, tau, laser_wavelength, laser_intensity,\n tau_f = None, detuning = None, symbolic_print = None, numeric_print = None,\n rabi_scaling = None, rabi_factors = None, atomic_velocity = None):\n \"\"\"Function to create and populate the coupled differential equation matrix A for the laser-atom system.\n \n Returns:\n ndarray: Matrix which contains all thera coefficients for the set of coupled differential equations describing a laser-atom system. \n \"\"\"\n \n # Initialise matrix with zeros\n A = np.zeros((nn,nn), dtype = np.complex)\n \n # Calculate half-Rabi frequency\n rabi = halfRabiFreq(laser_intensity, tau, laser_wavelength)\n if(rabi_scaling != None): # For normalising the rabi frequency\n rabi = rabirabi_scaling\n else:\n rabi_scaling = 1 # For symbolic printing\n \n if(rabi_factors != None):\n if(len(rabi_factors) != len(Q)):\n print(\"rabi_factors must be the same length as Q! Each element of Q is multiplied by the corresponding rabi_factor.\")\n else:\n rabi_factors = [1 for q in Q] # Set Rabi factors to 1\n \n # Initialise null parameters\n if(atomic_velocity == None):\n atomic_velocity = 0\n \n # Populate A matrix\n rho_ggpp(A, n, E, G, Q, Q_decay, tau, rabi, rabi_factors, numeric_print = numeric_print)\n rho_eepp(A, n, E, G, Q, Q_decay, tau, rabi, rabi_factors, tau_f = tau_f, numeric_print = numeric_print)\n rho_ge(A, n, E, G, Q, Q_decay, tau, rabi, rabi_factors, laser_wavelength, atomic_velocity, tau_f = tau_f, detuning = detuning, numeric_print = numeric_print)\n rho_eg(A, n, E, G, Q, Q_decay, tau, rabi, rabi_factors, laser_wavelength, atomic_velocity, tau_f = tau_f, detuning = detuning, numeric_print = numeric_print)\n\n # Symbolic Printing\n if(symbolic_print == True):\n init_printing()\n symbolicPrintSystem(n, E, G, Q, Q_decay, tau_f, detuning, \n laser_wavelength, atomic_velocity, rabi_scaling, rabi_factors)\n \n return A\n\ndef rho_ggpp(A, n, E, G, Q, Q_decay, tau, rabi, rabi_factors, numeric_print = None):\n \"\"\" Function to populate the matrix A with coefficients for populations and atomic coherences of the ground states. \n \"\"\"\n # rho_gg''\n for g in G: # Start with looping over g and g'' for rho_gg''\n for gpp in G:\n row = index(g, gpp, n) # matrix positions of rho_gg'' in 1D array\n A[row, row] += -1.jdelta(g, gpp) # first term in equation\n for e in E:\n column = index(g, e, n)\n for i,q in enumerate(Q): # Sum over all polarisations\n A[row, column] += coupling(e, gpp, q)1.jrabirabi_factors[i]\n for e in E:\n column = index(e, gpp, n)\n for i,q in enumerate(Q): \n A[row, column] += -1.jcoupling(e, g, q)rabirabi_factors[i]\n for ep in E:\n for epp in E:\n column = index(epp, ep, n)\n column2 = index(ep, epp, n)\n sum_decay_channels = 0\n for gp in G:\n for qp in Q_decay: # Sum over decay channel polarisations\n sum_decay_channels += abs(coupling(epp, gp, qp)coupling(ep, gp, qp))\n if(sum_decay_channels != 0):\n if(ep.label == epp.label):\n for qp in Q_decay:\n A[row, column] += 1/(2tau)abs(coupling(ep, gpp, qp)coupling(epp,g, qp))/sum_decay_channels\n A[row, column2] += 1/(2tau)abs(coupling(epp, gpp, qp)coupling(ep, g, qp))/sum_decay_channels\n else: \n # Then this is a vertical coherence and the generalised decay constant must be evaluated\n decay_const = generalisedDecayConstant(ep, epp, gpp, G, Q_decay)/(2tau) # Divide by two to take into account double counting of e'e'' and e''e'\n A[row, column] += decay_const\n A[row, column2] += decay_const\n \n if(numeric_print == True): # Print numerical equations\n print(\"rho_dot\", g.label, gpp.label, \" = \")\n for line in range(nn):\n if (A[row, line] != 0):\n print(A[row, line], \"rho\", getStateLabelsFromLineNo(line, n))\n\ndef rho_eepp(A, n, E, G, Q, Q_decay, tau, rabi, rabi_factors, tau_f = None, numeric_print = None):\n \"\"\" Function to populate the matrix A with coefficients for populations and atomic coherences of the excited states. \n \"\"\"\n # rho_ee''\n for e in E:\n for epp in E:\n row = index(e, epp, n)\n A[row, row] += -1.jdelta(e, epp) - 1/(tau)\n if(tau_f != None):\n A[row, row] -= 1/tau_f\n for g in G:\n column = index(e, g, n)\n for i,q in enumerate(Q):\n A[row, column] += 1.jcoupling(epp, g, q)rabirabi_factors[i]\n for g in G:\n column = index(g, epp, n)\n for i,q in enumerate(Q): \n A[row, column] += -1.jcoupling(e, g, q)rabirabi_factors[i]\n if(numeric_print == True):\n print(\"rho_dot\", e.label, epp.label, \" = \")\n for line in range(nn):\n if (A[row, line] != 0):\n print(A[row, line], \"rho\", getStateLabelsFromLineNo(line, n))\n\ndef rho_ge(A, n, E, G, Q, Q_decay, tau, rabi, rabi_factors, laser_wavelength, atomic_velocity, tau_f = None, detuning = None, numeric_print = None):\n \"\"\" Function to populate the matrix A with coefficients for optical coherences between ground and excited states. \n \"\"\"\n # rho_ge\n for g in G:\n for e in E: \n row = index(g, e, n)\n A[row, row] += -1.jdopplerDelta(e, g, w_q = angularFreq(laser_wavelength),\n lambda_q = laser_wavelength, v_z = atomic_velocity) - 1/(2tau)\n if(detuning != None):\n A[row, row] += -1.jdetuning\n if(tau_f != None):\n A[row, row] -= 1/(2tau_f)\n for ep in E:\n column = index(ep, e, n)\n for i,q in enumerate(Q): \n A[row, column] += -1.jcoupling(ep, g, q)rabirabi_factors[i]\n for gp in G:\n column = index(g, gp, n)\n for i,q in enumerate(Q): \n A[row, column] += 1.jcoupling(e, gp, q)rabirabi_factors[i]\n if(numeric_print == True):\n print(\"rho_dot\", g.label, e.label, \" = \")\n for line in range(nn):\n if (A[row, line] != 0):\n print(A[row, line], \"rho\", getStateLabelsFromLineNo(line, n))\n\ndef rho_eg(A, n, E, G, Q, Q_decay, tau, rabi, rabi_factors, laser_wavelength, atomic_velocity, tau_f = None, detuning = None, numeric_print = None):\n \"\"\" Function to populate the matrix A with coefficients for optical coherences between excited and ground states. \n \"\"\"\n # rho_eg\n for e in E:\n for g in G: \n row = index(e, g, n)\n A[row, row] += 1.jdopplerDelta(e, g, w_q = angularFreq(laser_wavelength), \n lambda_q = laser_wavelength, v_z = atomic_velocity) - 1/(2tau)\n if(detuning != None):\n A[row, row] += 1.jdetuning\n if(tau_f != None):\n A[row, row] -= 1/(2tau_f)\n for ep in E:\n column = index(e, ep, n)\n for i,q in enumerate(Q): \n A[row, column] += 1.jcoupling(ep, g, q)rabirabi_factors[i]\n for gp in G:\n column = index(gp, g, n)\n for i,q in enumerate(Q): \n A[row, column] += -1.jcoupling(e, gp, q)rabirabi_factors[i]\n if(numeric_print == True):\n print(\"rho_dot\", e.label, g.label, \" = \")\n for line in range(nn):\n if (A[row, line] != 0):\n print(A[row, line], \"rho\", getStateLabelsFromLineNo(line, n))" ]	[ [ "numpy.zeros" ] ]
RDLLab/benevolent-deception-gym	[ "4d04e097609097e0f07c661aac221184ebdec2fe" ]	[ "bdgym/envs/driver_assistant/policy.py" ]	[ "\"\"\"Driver Policies for the Driver Assistant Environment \"\"\"\nfrom copy import deepcopy\nfrom typing import Tuple, Optional, List, Dict\n\nimport numpy as np\n\nfrom highway_env.utils import not_zero, do_every\nfrom highway_env.types import Vector\nfrom highway_env.road.lane import AbstractLane\nfrom highway_env.envs.common.action import Action\nfrom highway_env.vehicle.kinematics import Vehicle\nfrom highway_env.vehicle.behavior import IDMVehicle\nfrom highway_env.road.road import Road, LaneIndex, Route\n\nimport bdgym.envs.utils as utils\nfrom bdgym.envs.driver_assistant.action import AssistantDiscreteAction\nfrom bdgym.envs.driver_assistant.vehicle import DriverAssistantVehicle\nfrom bdgym.envs.driver_assistant.driver_types import \\\n sample_driver_config, DRIVER_PARAM_LIMITS\n\nObservation = np.ndarray\n\n\nclass IDMDriverPolicy(IDMVehicle):\n \"\"\"A driver Policy that acts similar to IDMVehicle.\n\n Key difference is that it's decisions are based on the observations\n of it's own position and velocity that it recieves from the assistant and\n the noisy observations it recieves about the other nearby vehicles\n \"\"\"\n\n MAX_SPEED = DriverAssistantVehicle.MAX_SPEED\n\n def __init__(self,\n road: Road,\n position: Vector,\n heading: float = 0,\n speed: float = 0,\n target_lane_index: int = None,\n target_speed: float = None,\n route: Route = None,\n enable_lane_change: bool = True,\n timer: float = None,\n acc_max: float = None,\n comfort_acc_max: float = None,\n comfort_acc_min: float = None,\n distance_wanted: float = None,\n time_wanted: float = None,\n delta: float = None,\n politeness: float = None,\n lane_change_min_acc_gain: float = None,\n lane_change_max_braking_imposed: float = None,\n lane_change_delay: float = None,\n *kwargs):\n super().__init__(\n road,\n position,\n heading=heading,\n speed=speed,\n target_lane_index=target_lane_index,\n target_speed=target_speed,\n route=route,\n enable_lane_change=enable_lane_change,\n timer=timer\n )\n\n self.acc_max = self.ACC_MAX if acc_max is None else acc_max\n self.comfort_acc_max = self.COMFORT_ACC_MAX \\\n if comfort_acc_max is None else comfort_acc_max\n self.comfort_acc_min = self.COMFORT_ACC_MIN \\\n if comfort_acc_min is None else comfort_acc_min\n self.distance_wanted = self.DISTANCE_WANTED \\\n if distance_wanted is None else distance_wanted\n self.time_wanted = self.TIME_WANTED \\\n if time_wanted is None else time_wanted\n self.delta = self.DELTA if delta is None else delta\n self.politeness = self.POLITENESS if politeness is None else politeness\n self.lane_change_min_acc_gain = self.LANE_CHANGE_MIN_ACC_GAIN \\\n if lane_change_min_acc_gain is None else lane_change_min_acc_gain\n self.lane_change_max_braking_imposed = \\\n self.LANE_CHANGE_MAX_BRAKING_IMPOSED \\\n if lane_change_max_braking_imposed is None \\\n else lane_change_max_braking_imposed\n self.lane_change_delay = self.LANE_CHANGE_DELAY \\\n if lane_change_delay is None else lane_change_delay\n\n if timer is None:\n self.timer = (np.sum(self.position)np.pi) % self.lane_change_delay\n\n @classmethod\n def create_from(cls, vehicle: Vehicle, kwargs) -> \"IDMDriverPolicy\":\n \"\"\"\n Create a new vehicle from an existing one.\n\n The vehicle dynamics are copied, other properties are default.\n\n :param vehicle: a vehicle\n :return: a new vehicle at the same dynamical state\n \"\"\"\n return cls(\n road=vehicle.road,\n position=vehicle.position,\n heading=vehicle.heading,\n speed=vehicle.speed,\n kwargs\n )\n\n def get_action(self, obs: np.ndarray, dt: float) -> Action:\n \"\"\"\n Get the next action driver will take\n\n Note: assistant signal and other vehicle observations should\n be non-normalized values.\n\n :param obs: the driver observation of ego and neighbouring vehicles\n ['presence', 'x', 'y', 'vx', 'vy', 'acceleration', 'steering']\n :param dt: the step size for action\n :return: action ['acceleration', 'steering'] the vehicle would take\n \"\"\"\n assistant_signal, other_vehicle_obs = self.parse_obs(obs)\n self._update_dynamics(assistant_signal, dt)\n return self._get_idm_action(other_vehicle_obs)\n\n @staticmethod\n def parse_obs(obs: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:\n \"\"\"Parse driver observation into ego and other vehicle obs \"\"\"\n # for ego vehicle ignore 'presence' feature\n assistant_signal = obs[0][1:]\n # for other vehicle obs ignore 'acceleration' and 'steering' as these\n # are always 0.0 for other vehicles\n other_vehicle_obs = obs[1:, :-2]\n return assistant_signal, other_vehicle_obs\n\n def _update_dynamics(self, ego_vehicle_obs: Action, dt: float):\n self.position = ego_vehicle_obs[0:2]\n vx, vy = ego_vehicle_obs[2], ego_vehicle_obs[3]\n self.speed, self.heading = self._get_speed_and_heading(vx, vy)\n if self.road:\n self.lane_index = self.road.network.get_closest_lane_index(\n self.position\n )\n self.lane = self.road.network.get_lane(self.lane_index)\n # self.road.update_nearest_neighbours()\n\n self.timer += dt\n\n @staticmethod\n def _get_speed_and_heading(vx: float, vy: float) -> Tuple[float, float]:\n speed = np.sqrt(vx2 + vy2)\n if speed == 0.0:\n # vx = vy = 0.0\n heading = 0.0\n elif vx == 0.0:\n heading = np.arcsin(vy / speed)\n elif vy == 0.0:\n heading = np.arccos(vx / speed)\n else:\n heading = np.arctan(vy / vx)\n return speed, heading\n\n @staticmethod\n def _get_direction(heading: float) -> np.ndarray:\n return np.array([np.cos(heading), np.sin(heading)])\n\n @property\n def observation(self) -> np.ndarray:\n \"\"\"Vehicle position and velocity in standard observation format \"\"\"\n return np.array([1.0, self.position, self.velocity])\n\n @property\n def configuration(self) -> dict:\n \"\"\"The driver policy parameters \"\"\"\n config = {\n param: self.__getattribute__(param)\n for param in DRIVER_PARAM_LIMITS\n }\n return config\n\n def _get_idm_action(self, other_vehicle_obs: np.ndarray) -> np.ndarray:\n # Lateral: MOBIL\n self.follow_road()\n if self.enable_lane_change:\n self._change_lane_policy(other_vehicle_obs)\n steering = self.steering_control(self.target_lane_index)\n steering = np.clip(\n steering, -self.MAX_STEERING_ANGLE, self.MAX_STEERING_ANGLE\n )\n\n # Longitudinal: IDM\n front_vehicle_obs, _ = self._get_neighbours(other_vehicle_obs)\n acceleration = self._acceleration_from_obs(front_vehicle_obs)\n acceleration = np.clip(acceleration, -1self.acc_max, self.acc_max)\n return np.array([acceleration, steering])\n\n def _acceleration_from_obs(self, front_vehicle_obs: np.ndarray) -> float:\n acceleration = self.comfort_acc_max (\n 1 - np.power(max(self.speed, 0) / self.target_speed, self.delta)\n )\n\n if front_vehicle_obs is not None:\n front_pos = front_vehicle_obs[1:3]\n d = (\n self.lane.local_coordinates(front_pos)[0]\n - self.lane.local_coordinates(self.position)[0]\n )\n gap = self._desired_gap_from_obs(front_vehicle_obs)\n gap /= not_zero(d)\n acceleration -= self.comfort_acc_max * np.power(gap, 2)\n\n return acceleration\n\n def _acceleration(self,\n ego_xy: Tuple[float, float],\n ego_velocity: Tuple[float, float],\n front_xy: Tuple[float, float] = None,\n front_velocity: Tuple[float, float] = None,\n lane: AbstractLane = None) -> float:\n ego_target_speed = not_zero(0)\n ego_speed, ego_heading = self._get_speed_and_heading(ego_velocity)\n speed = max(ego_speed, 0) / ego_target_speed\n\n acceleration = self.comfort_acc_max (\n 1 - np.power(speed, self.delta)\n )\n\n if front_xy is not None:\n if lane is None:\n lane = self.lane\n\n d = (\n lane.local_coordinates(front_xy)[0]\n - lane.local_coordinates(ego_xy)[0]\n )\n ego_direction = self._get_direction(ego_heading)\n gap = self._desired_gap(\n ego_velocity, ego_speed, ego_direction, front_velocity\n )\n gap /= not_zero(d)\n acceleration -= self.comfort_acc_max * np.power(gap, 2)\n return acceleration\n\n def _desired_gap_from_obs(self, vehicle_obs: np.ndarray):\n other_velocity = vehicle_obs[3:4]\n return self._desired_gap(\n self.velocity, self.speed, self.direction, other_velocity\n )\n\n def _desired_gap(self,\n ego_velocity: np.ndarray,\n ego_speed: float,\n ego_direction: float,\n other_velocity: np.ndarray) -> float:\n d0 = self.distance_wanted\n tau = self.time_wanted\n ab = -1self.comfort_acc_max self.comfort_acc_min\n dv = np.dot(ego_velocity - other_velocity, ego_direction)\n d_star = d0 + ego_speed * tau + ego_speed * dv / (2 * np.sqrt(ab))\n return d_star\n\n def _get_neighbours(self,\n other_vehicle_obs: np.ndarray,\n lane_index: LaneIndex = None\n ) -> Tuple[Optional[Vehicle], Optional[Vehicle]]:\n \"\"\"Get closest vehicles to ego vehicle within specified lane \"\"\"\n if lane_index is None:\n lane_index = self.lane_index\n\n lane = self.road.network.get_lane(lane_index)\n ego_lane_x = lane.local_coordinates(self.position)[0]\n\n closest_front = None\n min_front_distance = float('inf')\n closest_rear = None\n min_rear_distance = float('inf')\n\n for other in other_vehicle_obs:\n other_xy = other[1:3]\n if not lane.on_lane(other_xy):\n continue\n\n other_lane_x = lane.local_coordinates(other_xy)[0]\n distance = abs(other_lane_x - ego_lane_x)\n if ego_lane_x < other_lane_x and distance < min_front_distance:\n closest_front = other\n min_front_distance = distance\n elif ego_lane_x > other_lane_x and distance < min_rear_distance:\n closest_rear = other\n min_rear_distance = distance\n\n return closest_front, closest_rear\n\n def _change_lane_policy(self, other_vehicle_obs: np.ndarray) -> None:\n # at a given frequency,\n if not do_every(self.lane_change_delay, self.timer):\n return\n self.timer = 0\n\n # decide to make a lane change\n for lane_index in self.road.network.side_lanes(self.lane_index):\n # Is the candidate lane close enough?\n if not self.road.network.get_lane(lane_index).is_reachable_from(\n self.position):\n continue\n # Does the MOBIL model recommend a lane change?\n if self._mobil(lane_index, other_vehicle_obs):\n self.target_lane_index = lane_index\n\n def _mobil(self,\n lane_index: LaneIndex,\n other_vehicle_obs: np.ndarray) -> bool:\n \"\"\" Overrides parent \"\"\"\n # Is the maneuver unsafe for the new following vehicle?\n new_preceding, new_following = self._get_neighbours(\n other_vehicle_obs, lane_index\n )\n\n lane = self.road.network.get_lane(lane_index)\n ego_obs = self.observation\n\n new_following_a, new_following_pred_a = self._acceleration_changes(\n following=new_following,\n preceding=new_preceding,\n new_preceding=ego_obs,\n lane=lane\n )\n if new_following_pred_a < -1self.lane_change_max_braking_imposed:\n return False\n\n # Do I have a planned route for a specific lane which is safe for me\n # to access?\n old_preceding, old_following = self._get_neighbours(other_vehicle_obs)\n self_pred_a = self._acceleration_from_obs(new_preceding)\n\n if self.route and self.route[0][2]:\n # Wrong direction\n if np.sign(lane_index[2] - self.target_lane_index[2]) \\\n != np.sign(self.route[0][2] - self.target_lane_index[2]):\n return False\n # Unsafe braking required\n if self_pred_a < -1self.lane_change_max_braking_imposed:\n return False\n else:\n # Is there an acceleration advantage for me and/or my\n # followers to change lane?\n self_a = self._acceleration_from_obs(old_preceding)\n\n old_following_a, old_following_pred_a = self._acceleration_changes(\n following=old_following,\n preceding=ego_obs,\n new_preceding=old_preceding\n )\n\n jerk = self_pred_a - self_a\n jerk += self.politeness * (\n new_following_pred_a - new_following_a\n + old_following_pred_a - old_following_a\n )\n if jerk < self.lane_change_min_acc_gain:\n return False\n\n # All clear, let's go!\n return True\n\n def _acceleration_changes(self,\n following: np.ndarray,\n preceding: np.ndarray,\n new_preceding: np.ndarray,\n lane: AbstractLane = None\n ) -> Tuple[float, float]:\n following_a = 0.0\n following_pred_a = 0.0\n if following is not None and preceding is not None:\n following_a = self._acceleration(\n ego_xy=following[1:3],\n ego_velocity=following[3:5],\n front_xy=preceding[1:3],\n front_velocity=preceding[3:5],\n lane=lane\n )\n\n if following is not None and new_preceding is not None:\n following_pred_a = self._acceleration(\n ego_xy=following[1:3],\n ego_velocity=following[3:5],\n front_xy=new_preceding[1:3],\n front_velocity=new_preceding[3:5],\n lane=lane\n )\n return following_a, following_pred_a\n\n\nclass IDMAssistantPolicy(IDMDriverPolicy):\n \"\"\"An IDM Assistant policy that provides vehicle obs and recommendation\n\n Specifically:\n - Returns the actual observations recieved for the driver vehicle\n - Recommends acceleration and steering controls to the driver based on IDM\n model\n \"\"\"\n\n def __init__(self,\n road: Road,\n position: Vector,\n args,\n action_ranges: Optional[Dict[str, List[float]]] = None,\n normalize: bool = True,\n kwargs):\n super().__init__(road, position, args, *kwargs)\n self.action_ranges = {}\n if action_ranges is not None:\n self.action_ranges = action_ranges\n self.normalize = normalize\n\n def get_action(self, obs: np.ndarray, dt: float) -> Action:\n \"\"\"\n Get the next action assistant will take\n\n :param full_obs: full observation of vehicle including of nearby\n vehicles. Includes ['presence', 'x', 'y', 'vx', 'vy']\n :return: the assistant action\n ['x', 'y', 'vx', 'vy', 'acceleration', 'steering']\n \"\"\"\n other_vehicle_obs = obs[1:, :]\n assistant_signal = obs[0, 1:]\n self._update_dynamics(assistant_signal, dt)\n recommended_controls = self._get_idm_action(other_vehicle_obs)\n\n action = np.concatenate((assistant_signal, recommended_controls))\n\n if self.normalize:\n for i, frange in enumerate(self.action_ranges.values()):\n action[i] = utils.lmap(\n action[i], frange, [-1, 1]\n )\n\n return action\n\n\nclass RandomAssistantPolicy(IDMAssistantPolicy):\n \"\"\"A Random Assistant policy\n\n Specifically:\n - Returns the actual observations recieved for the driver vehicle\n - Recommends a random acceleration and steering control to the driver\n \"\"\"\n\n def get_action(self, obs: np.ndarray, dt: float) -> Action:\n \"\"\" Overrides IDMDriverVehicle.get_action() \"\"\"\n action = super().get_action(obs, dt)\n action[4] = utils.get_truncated_normal(0.0, 1.0, -1.0, 1.0)\n action[5] = utils.get_truncated_normal(0.0, 1.0, -1.0, 1.0)\n return action\n\n\nclass RandomDiscreteAssistantPolicy(IDMAssistantPolicy):\n \"\"\"A Random Assistant policy for Discrete Assistant Action\n\n Specifically:\n - Returns the actual observations recieved for the driver vehicle\n - Recommends a random acceleration and steering control to the driver\n \"\"\"\n\n def get_action(self, obs: np.ndarray, dt: float) -> Action:\n \"\"\" Overrides IDMDriverVehicle.get_action() \"\"\"\n avail_actions = [\n AssistantDiscreteAction.NOOP,\n AssistantDiscreteAction.UP,\n AssistantDiscreteAction.DOWN\n ]\n action = np.full(\n AssistantDiscreteAction.ASSISTANT_DISCRETE_ACTION_SPACE_SIZE,\n AssistantDiscreteAction.NOOP\n )\n action[4] = np.random.choice(avail_actions)\n action[5] = np.random.choice(avail_actions)\n return action\n\n\nclass DoNothingDiscreteAssistantPolicy(IDMAssistantPolicy):\n \"\"\"Assistant policy that recommends no action and applies no deception \"\"\"\n\n def get_action(self, obs: np.ndarray, dt: float) -> Action:\n \"\"\" Overrides IDMDriverVehicle.get_action() \"\"\"\n action = np.full(\n AssistantDiscreteAction.ASSISTANT_DISCRETE_ACTION_SPACE_SIZE,\n AssistantDiscreteAction.NOOP\n )\n return action\n\n\nclass RandomDriverPolicy(IDMDriverPolicy):\n \"\"\"A Random driver policy \"\"\"\n\n def get_action(self, obs: np.ndarray, dt: float) -> Action:\n \"\"\" Overrides IDMDriverVehicle.get_action() \"\"\"\n assistant_signal, _ = self.parse_obs(obs)\n self._update_dynamics(assistant_signal, dt)\n return np.random.uniform(\n low=[-1self.acc_max, -1self.MAX_STEERING_ANGLE],\n high=[self.acc_max, self.MAX_STEERING_ANGLE],\n )\n\n\nclass GuidedIDMDriverPolicy(IDMDriverPolicy):\n \"\"\"A Driver policy that also considers recommended actions from assistant\n\n How much the driver follows the assistant's suggestions versus relying on\n the IDM driver model is controlled by the \"independence\" hyperparameter\n \"\"\"\n\n def __init__(self,\n road: Road,\n position: Vector,\n args,\n independence: float = 0.9,\n *kwargs):\n super().__init__(road, position, args, *kwargs)\n self.independence = independence\n\n @property\n def configuration(self) -> dict:\n \"\"\"The driver policy parameters \"\"\"\n config = super().configuration\n config[\"independence\"] = self.independence\n return config\n\n def get_action(self, obs: np.ndarray, dt: float) -> Action:\n \"\"\" Overrides IDMDriverVehicle.get_action() \"\"\"\n assistant_signal, other_vehicle_obs = self.parse_obs(obs)\n self._update_dynamics(assistant_signal, dt)\n idm_action = self._get_idm_action(other_vehicle_obs)\n action = self._calc_action(assistant_signal[-2:], idm_action)\n return action\n\n def _calc_action(self,\n assistant_action: np.ndarray,\n idm_action: np.ndarray) -> np.ndarray:\n return (\n (1 - self.independence) assistant_action\n + (self.independence * idm_action)\n )\n\n\nclass ChangingGuidedIDMDriverPolicy(GuidedIDMDriverPolicy):\n \"\"\"A GuidedIDMDriverPolicy where the driver parameters can be re-sampled\n\n How much the driver follows the assistant's suggestions versus relying on\n the IDM driver model is controlled by the \"independence\" hyperparameter\n \"\"\"\n\n INDEPENDENCE_DIST = utils.get_truncated_normal(\n 0.5, 0.25, 0.0, 1.0\n )\n\n def __init__(self,\n road: Road,\n position: Vector,\n args,\n independence: float = 0.9,\n kwargs):\n super().__init__(road, position, args, *kwargs)\n self.independence = independence\n\n def get_action(self, obs: np.ndarray, dt: float) -> Action:\n \"\"\" Overrides IDMDriverVehicle.get_action() \"\"\"\n assistant_signal, other_vehicle_obs = self.parse_obs(obs)\n self._update_dynamics(assistant_signal, dt)\n idm_action = self._get_idm_action(other_vehicle_obs)\n action = self._calc_action(assistant_signal[-2:], idm_action)\n return action\n\n def _calc_action(self,\n assistant_action: np.ndarray,\n idm_action: np.ndarray) -> np.ndarray:\n return (\n (1 - self.independence) assistant_action\n + (self.independence * idm_action)\n )\n\n @classmethod\n def create_from(cls, vehicle: Vehicle, kwargs) -> \"IDMDriverPolicy\":\n \"\"\"\n Create a new vehicle from an existing one.\n\n The vehicle dynamics are copied, other properties are default.\n\n :param vehicle: a vehicle\n :return: a new vehicle at the same dynamical state\n \"\"\"\n driver_config = deepcopy(kwargs)\n driver_config.update(sample_driver_config())\n\n if kwargs.get(\"force_independent\", False):\n driver_config[\"independence\"] = 1.0\n else:\n driver_config[\"independence\"] = cls.INDEPENDENCE_DIST.rvs()\n\n return cls(\n road=vehicle.road,\n position=vehicle.position,\n heading=vehicle.heading,\n speed=vehicle.speed,\n kwargs\n )\n\n\ndef driver_policy_factory(env, driver_config: dict) -> 'IDMDriverPolicy':\n \"\"\"Get the driver policy for given driver configuration \"\"\"\n if driver_config[\"type\"] == \"RandomDriverPolicy\":\n policy_cls = RandomDriverPolicy\n elif driver_config[\"type\"] == \"GuidedIDMDriverPolicy\":\n policy_cls = GuidedIDMDriverPolicy\n elif driver_config[\"type\"] == \"ChangingGuidedIDMDriverPolicy\":\n policy_cls = ChangingGuidedIDMDriverPolicy\n else:\n raise ValueError(f\"Unsupported Driver Type: {driver_config['type']}\")\n\n return policy_cls.create_from(env.vehicle, **driver_config)\n" ]	[ [ "numpy.dot", "numpy.sqrt", "numpy.arctan", "numpy.clip", "numpy.random.choice", "numpy.arcsin", "numpy.power", "numpy.cos", "numpy.arccos", "numpy.full", "numpy.concatenate", "numpy.sin", "numpy.sign", "numpy.random.uniform", "numpy.array", "numpy.sum" ] ]
chaseaucoin/Neural-Primer	[ "d5163af8cd74ea5cea620069dffca8c124bffc05" ]	[ "Numpy XOR/Tensor_ImageRecognition.py" ]	[ "from tensorflow.examples.tutorials.mnist import input_data\r\n\r\n#Get The MNIST Data\r\nmnist = input_data.read_data_sets(\"MNIST_data/\", one_hot=True)\r\n\r\nimport tensorflow as tf\r\n\r\n# Create the model\r\ninputs = tf.placeholder(tf.float32, [None, 784])\r\nweights = tf.Variable(tf.zeros([784, 10]))\r\nbiases = tf.Variable(tf.zeros([10]))\r\npredictions = tf.matmul(inputs, weights) + biases\r\n\r\n# Define loss and optimizer\r\nexpectedPredictions = tf.placeholder(tf.float32, [None, 10])\r\n\r\n# The raw formulation of cross-entropy,\r\n#\r\n# tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(tf.nn.softmax(y)),\r\n# reduction_indices=[1]))\r\n#\r\n# can be numerically unstable.\r\n#\r\n# So here we use tf.nn.softmax_cross_entropy_with_logits on the raw\r\n# outputs of 'y', and then average across the batch.\r\n\r\nmeanError = tf.reduce_mean(\r\n tf.nn.softmax_cross_entropy_with_logits(labels=expectedPredictions, logits=predictions))\r\n\r\ntrain_step = tf.train.GradientDescentOptimizer(0.1).minimize(meanError)\r\n\r\nsess = tf.InteractiveSession()\r\ntf.global_variables_initializer().run()\r\n# Train\r\nfor _ in range(1000):\r\n batch_xs, batch_ys = mnist.train.next_batch(100)\r\n sess.run(train_step, feed_dict={inputs: batch_xs, expectedPredictions: batch_ys})\r\n\r\n # Test trained model\r\n correct_prediction = tf.equal(tf.argmax(predictions, 1), tf.argmax(expectedPredictions, 1))\r\n accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\r\n print(sess.run(accuracy, feed_dict={inputs: mnist.test.images,\r\n expectedPredictions: mnist.test.labels}))" ]	[ [ "tensorflow.matmul", "tensorflow.nn.softmax_cross_entropy_with_logits", "tensorflow.InteractiveSession", "tensorflow.zeros", "tensorflow.cast", "tensorflow.placeholder", "tensorflow.global_variables_initializer", "tensorflow.train.GradientDescentOptimizer", "tensorflow.argmax", "tensorflow.examples.tutorials.mnist.input_data.read_data_sets" ] ]
dan0nchik/FLAML	[ "9d661759b49de6e403d9288af7a015606528fe7e" ]	[ "flaml/model.py" ]	[ "'''!\r\n * Copyright (c) 2020-2021 Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License. \r\n'''\r\n\r\nimport numpy as np\r\nimport xgboost as xgb\r\nimport time\r\nfrom sklearn.ensemble import RandomForestRegressor, RandomForestClassifier\r\nfrom sklearn.ensemble import ExtraTreesRegressor, ExtraTreesClassifier\r\nfrom sklearn.linear_model import LogisticRegression\r\nfrom lightgbm import LGBMClassifier, LGBMRegressor\r\nfrom scipy.sparse import issparse\r\nimport pandas as pd\r\nfrom . import tune\r\n\r\nimport logging\r\nlogger = logging.getLogger(__name__)\r\n\r\n\r\nclass BaseEstimator:\r\n '''The abstract class for all learners\r\n\r\n Typical example:\r\n XGBoostEstimator: for regression\r\n XGBoostSklearnEstimator: for classification\r\n LGBMEstimator, RandomForestEstimator, LRL1Classifier, LRL2Classifier: \r\n for both regression and classification \r\n '''\r\n\r\n def __init__(self, task = 'binary:logistic', params):\r\n '''Constructor\r\n \r\n Args:\r\n task: A string of the task type, one of\r\n 'binary:logistic', 'multi:softmax', 'regression'\r\n n_jobs: An integer of the number of parallel threads\r\n params: A dictionary of the hyperparameter names and values\r\n '''\r\n self.params = params\r\n self.estimator_class = self._model = None\r\n self._task = task\r\n if '_estimator_type' in params:\r\n self._estimator_type = params['_estimator_type']\r\n else:\r\n self._estimator_type = \"regressor\" if task=='regression' \\\r\n else \"classifier\" \r\n\r\n def get_params(self, deep=False):\r\n params = self.params.copy()\r\n params[\"task\"] = self._task\r\n if hasattr(self, '_estimator_type'):\r\n params['_estimator_type'] = self._estimator_type\r\n return params\r\n\r\n @property\r\n def classes_(self):\r\n return self._model.classes_\r\n\r\n @property\r\n def n_features_in_(self): \r\n return self.model.n_features_in_\r\n\r\n @property\r\n def model(self):\r\n '''Trained model after fit() is called, or None before fit() is called\r\n '''\r\n return self._model\r\n\r\n def _preprocess(self, X):\r\n return X\r\n\r\n def _fit(self, X_train, y_train, kwargs): \r\n\r\n curent_time = time.time()\r\n X_train = self._preprocess(X_train)\r\n model = self.estimator_class(self.params)\r\n model.fit(X_train, y_train, kwargs)\r\n train_time = time.time() - curent_time\r\n self._model = model\r\n return train_time\r\n\r\n def fit(self, X_train, y_train, budget=None, *kwargs):\r\n '''Train the model from given training data\r\n \r\n Args:\r\n X_train: A numpy array of training data in shape nm\r\n y_train: A numpy array of labels in shape n1\r\n budget: A float of the time budget in seconds\r\n\r\n Returns:\r\n train_time: A float of the training time in seconds\r\n '''\r\n return self._fit(X_train, y_train, kwargs)\r\n\r\n def predict(self, X_test):\r\n '''Predict label from features\r\n \r\n Args:\r\n X_test: A numpy array of featurized instances, shape nm\r\n\r\n Returns:\r\n A numpy array of shape n1. \r\n Each element is the label for a instance\r\n ''' \r\n X_test = self._preprocess(X_test)\r\n return self._model.predict(X_test)\r\n\r\n def predict_proba(self, X_test):\r\n '''Predict the probability of each class from features\r\n\r\n Only works for classification problems\r\n\r\n Args:\r\n model: An object of trained model with method predict_proba()\r\n X_test: A numpy array of featurized instances, shape nm\r\n\r\n Returns:\r\n A numpy array of shape nc. c is the # classes\r\n Each element at (i,j) is the probability for instance i to be in\r\n class j\r\n '''\r\n if 'regression' in self._task:\r\n print('Regression tasks do not support predict_prob')\r\n raise ValueError\r\n else:\r\n X_test = self._preprocess(X_test)\r\n return self._model.predict_proba(X_test)\r\n\r\n def cleanup(self): pass\r\n\r\n @classmethod\r\n def search_space(cls, params): \r\n '''[required method] search space\r\n\r\n Returns:\r\n A dictionary of the search space. \r\n Each key is the name of a hyperparameter, and value is a dict with\r\n its domain and init_value (optional), cat_hp_cost (optional) \r\n e.g., \r\n {'domain': tune.randint(lower=1, upper=10), 'init_value': 1}\r\n '''\r\n return {}\r\n\r\n @classmethod\r\n def size(cls, config): \r\n '''[optional method] memory size of the estimator in bytes\r\n \r\n Args:\r\n config - the dict of the hyperparameter config\r\n\r\n Returns:\r\n A float of the memory size required by the estimator to train the\r\n given config\r\n '''\r\n return 1.0\r\n\r\n @classmethod\r\n def cost_relative2lgbm(cls):\r\n '''[optional method] relative cost compared to lightgbm'''\r\n return 1.0\r\n\r\n\r\nclass SKLearnEstimator(BaseEstimator):\r\n\r\n\r\n def _preprocess(self, X):\r\n if isinstance(X, pd.DataFrame):\r\n X = X.copy()\r\n cat_columns = X.select_dtypes(include=['category']).columns\r\n X[cat_columns] = X[cat_columns].apply(lambda x: x.cat.codes)\r\n return X\r\n\r\n\r\nclass LGBMEstimator(BaseEstimator):\r\n\r\n\r\n @classmethod\r\n def search_space(cls, data_size, params): \r\n upper = min(32768,int(data_size))\r\n return {\r\n 'n_estimators': {\r\n 'domain': tune.qloguniform(lower=4, upper=upper, q=1),\r\n 'init_value': 4,\r\n },\r\n 'max_leaves': {\r\n 'domain': tune.qloguniform(lower=4, upper=upper, q=1),\r\n 'init_value': 4,\r\n },\r\n 'min_child_weight': {\r\n 'domain': tune.loguniform(lower=0.001, upper=20.0),\r\n 'init_value': 20.0,\r\n },\r\n 'learning_rate': {\r\n 'domain': tune.loguniform(lower=0.01, upper=1.0),\r\n 'init_value': 0.1,\r\n },\r\n 'subsample': {\r\n 'domain': tune.uniform(lower=0.6, upper=1.0),\r\n 'init_value': 1.0,\r\n }, \r\n 'log_max_bin': {\r\n 'domain': tune.qloguniform(lower=3, upper=10, q=1),\r\n 'init_value': 8,\r\n }, \r\n 'colsample_bytree': {\r\n 'domain': tune.uniform(lower=0.7, upper=1.0),\r\n 'init_value': 1.0,\r\n }, \r\n 'reg_alpha': {\r\n 'domain': tune.loguniform(lower=1e-10, upper=1.0),\r\n 'init_value': 1e-10,\r\n }, \r\n 'reg_lambda': {\r\n 'domain': tune.loguniform(lower=1e-10, upper=1.0),\r\n 'init_value': 1.0,\r\n }, \r\n }\r\n\r\n @classmethod\r\n def size(cls, config):\r\n max_leaves = int(round(config['max_leaves']))\r\n n_estimators = int(round(config['n_estimators']))\r\n return (max_leaves3 + (max_leaves-1)4 + 1.0)n_estimators8\r\n\r\n def __init__(self, task='binary:logistic', n_jobs=1,\r\n n_estimators=2, max_leaves=2, min_child_weight=1e-3, learning_rate=0.1, \r\n subsample=1.0, reg_lambda=1.0, reg_alpha=0.0, colsample_bylevel=1.0, \r\n colsample_bytree=1.0, log_max_bin=8, params):\r\n super().__init__(task, params)\r\n # Default: ‘regression’ for LGBMRegressor, \r\n # ‘binary’ or ‘multiclass’ for LGBMClassifier\r\n if 'regression' in task:\r\n objective = 'regression'\r\n elif 'binary' in task:\r\n objective = 'binary'\r\n elif 'multi' in task:\r\n objective = 'multiclass'\r\n else: objective = 'regression'\r\n self.params = {\r\n \"n_estimators\": int(round(n_estimators)),\r\n \"num_leaves\": params[\r\n 'num_leaves'] if 'num_leaves' in params else int(\r\n round(max_leaves)),\r\n 'objective': params[\r\n \"objective\"] if \"objective\" in params else objective,\r\n 'n_jobs': n_jobs,\r\n 'learning_rate': float(learning_rate),\r\n 'reg_alpha': float(reg_alpha),\r\n 'reg_lambda': float(reg_lambda),\r\n 'min_child_weight': float(min_child_weight),\r\n 'colsample_bytree':float(colsample_bytree),\r\n 'subsample': float(subsample),\r\n }\r\n self.params['max_bin'] = params['max_bin'] if 'max_bin' in params else (\r\n 1<<int(round(log_max_bin)))-1\r\n if 'regression' in task:\r\n self.estimator_class = LGBMRegressor\r\n else:\r\n self.estimator_class = LGBMClassifier\r\n self._time_per_iter = None\r\n self._train_size = 0\r\n\r\n def _preprocess(self, X):\r\n if not isinstance(X, pd.DataFrame) and issparse(\r\n X) and np.issubdtype(X.dtype, np.integer):\r\n X = X.astype(float)\r\n return X\r\n\r\n def fit(self, X_train, y_train, budget=None, kwargs):\r\n start_time = time.time()\r\n n_iter = self.params[\"n_estimators\"]\r\n if (not self._time_per_iter or\r\n abs(self._train_size-X_train.shape[0])>4) and budget is not None:\r\n self.params[\"n_estimators\"] = 1\r\n self._t1 = self._fit(X_train, y_train, kwargs)\r\n if self._t1 >= budget: \r\n self.params[\"n_estimators\"] = n_iter\r\n return self._t1\r\n self.params[\"n_estimators\"] = 4\r\n self._t2 = self._fit(X_train, y_train, kwargs)\r\n self._time_per_iter = (self._t2 - self._t1)/(\r\n self.params[\"n_estimators\"]-1) if self._t2 > self._t1 \\\r\n else self._t1 if self._t1 else 0.001\r\n self._train_size = X_train.shape[0]\r\n if self._t1+self._t2>=budget or n_iter==self.params[\"n_estimators\"]:\r\n self.params[\"n_estimators\"] = n_iter\r\n return time.time() - start_time\r\n if budget is not None:\r\n self.params[\"n_estimators\"] = min(n_iter, int((budget-time.time()+\r\n start_time-self._t1)/self._time_per_iter+1))\r\n if self.params[\"n_estimators\"] > 0:\r\n self._fit(X_train, y_train, kwargs)\r\n self.params[\"n_estimators\"] = n_iter\r\n train_time = time.time() - start_time\r\n return train_time\r\n\r\n\r\nclass XGBoostEstimator(SKLearnEstimator):\r\n ''' not using sklearn API, used for regression '''\r\n\r\n\r\n @classmethod\r\n def search_space(cls, data_size, params): \r\n upper = min(32768,int(data_size))\r\n return {\r\n 'n_estimators': {\r\n 'domain': tune.qloguniform(lower=4, upper=upper, q=1),\r\n 'init_value': 4,\r\n },\r\n 'max_leaves': {\r\n 'domain': tune.qloguniform(lower=4, upper=upper, q=1),\r\n 'init_value': 4,\r\n },\r\n 'min_child_weight': {\r\n 'domain': tune.loguniform(lower=0.001, upper=20.0),\r\n 'init_value': 20.0,\r\n },\r\n 'learning_rate': {\r\n 'domain': tune.loguniform(lower=0.01, upper=1.0),\r\n 'init_value': 0.1,\r\n },\r\n 'subsample': {\r\n 'domain': tune.uniform(lower=0.6, upper=1.0),\r\n 'init_value': 1.0,\r\n }, \r\n 'colsample_bylevel': {\r\n 'domain': tune.uniform(lower=0.6, upper=1.0),\r\n 'init_value': 1.0,\r\n }, \r\n 'colsample_bytree': {\r\n 'domain': tune.uniform(lower=0.7, upper=1.0),\r\n 'init_value': 1.0,\r\n }, \r\n 'reg_alpha': {\r\n 'domain': tune.loguniform(lower=1e-10, upper=1.0),\r\n 'init_value': 1e-10,\r\n }, \r\n 'reg_lambda': {\r\n 'domain': tune.loguniform(lower=1e-10, upper=1.0),\r\n 'init_value': 1.0,\r\n }, \r\n }\r\n \r\n @classmethod\r\n def size(cls, config):\r\n return LGBMEstimator.size(config)\r\n\r\n @classmethod\r\n def cost_relative2lgbm(cls):\r\n return 1.6\r\n\r\n def __init__(self, task='regression', all_thread=False, n_jobs=1,\r\n n_estimators=4, max_leaves=4, subsample=1.0, min_child_weight=1, \r\n learning_rate=0.1, reg_lambda=1.0, reg_alpha=0.0, colsample_bylevel=1.0,\r\n colsample_bytree=1.0, tree_method='auto', params):\r\n super().__init__(task, params)\r\n self._n_estimators = int(round(n_estimators))\r\n self._max_leaves = int(round(max_leaves))\r\n self.params = {\r\n 'max_leaves': int(round(max_leaves)),\r\n 'max_depth': 0,\r\n 'grow_policy': params[\r\n \"grow_policy\"] if \"grow_policy\" in params else 'lossguide',\r\n 'tree_method':tree_method,\r\n 'verbosity': 0,\r\n 'nthread':n_jobs,\r\n 'learning_rate': float(learning_rate),\r\n 'subsample': float(subsample),\r\n 'reg_alpha': float(reg_alpha),\r\n 'reg_lambda': float(reg_lambda),\r\n 'min_child_weight': float(min_child_weight),\r\n 'booster': params['booster'] if 'booster' in params else 'gbtree',\r\n 'colsample_bylevel': float(colsample_bylevel),\r\n 'colsample_bytree':float(colsample_bytree),\r\n }\r\n if all_thread:\r\n del self.params['nthread']\r\n\r\n def get_params(self, deep=False):\r\n params = super().get_params()\r\n params[\"n_jobs\"] = params['nthread']\r\n return params\r\n\r\n def fit(self, X_train, y_train, budget=None, kwargs):\r\n start_time = time.time() \r\n if not issparse(X_train):\r\n self.params['tree_method'] = 'hist'\r\n X_train = self._preprocess(X_train)\r\n dtrain = xgb.DMatrix(X_train, label=y_train)\r\n if self._max_leaves>0:\r\n if 'sample_weight' in kwargs:\r\n self._model = xgb.train(self.params, dtrain,\r\n self._n_estimators, weight=kwargs['sample_weight'])\r\n else:\r\n self._model = xgb.train(self.params, dtrain, self._n_estimators)\r\n del dtrain\r\n train_time = time.time() - start_time\r\n return train_time\r\n else:\r\n return None\r\n\r\n def predict(self, X_test):\r\n if not issparse(X_test):\r\n X_test = self._preprocess(X_test)\r\n dtest = xgb.DMatrix(X_test)\r\n return super().predict(dtest)\r\n\r\n\r\nclass XGBoostSklearnEstimator(SKLearnEstimator, LGBMEstimator):\r\n ''' using sklearn API, used for classification '''\r\n\r\n\r\n @classmethod\r\n def search_space(cls, data_size, params): \r\n return XGBoostEstimator.search_space(data_size)\r\n\r\n @classmethod\r\n def cost_relative2lgbm(cls):\r\n return XGBoostEstimator.cost_relative2lgbm()\r\n\r\n def __init__(self, task='binary:logistic', n_jobs=1, \r\n n_estimators=4, max_leaves=4, subsample=1.0, \r\n min_child_weight=1, learning_rate=0.1, reg_lambda=1.0, reg_alpha=0.0,\r\n colsample_bylevel=1.0, colsample_bytree=1.0, tree_method='hist', \r\n params):\r\n super().__init__(task, params)\r\n self.params = {\r\n \"n_estimators\": int(round(n_estimators)),\r\n 'max_leaves': int(round(max_leaves)),\r\n 'max_depth': 0,\r\n 'grow_policy': params[\r\n \"grow_policy\"] if \"grow_policy\" in params else 'lossguide',\r\n 'tree_method':tree_method,\r\n 'verbosity': 0,\r\n 'n_jobs': n_jobs,\r\n 'learning_rate': float(learning_rate),\r\n 'subsample': float(subsample),\r\n 'reg_alpha': float(reg_alpha),\r\n 'reg_lambda': float(reg_lambda),\r\n 'min_child_weight': float(min_child_weight),\r\n 'booster': params['booster'] if 'booster' in params else 'gbtree',\r\n 'colsample_bylevel': float(colsample_bylevel),\r\n 'colsample_bytree': float(colsample_bytree),\r\n }\r\n\r\n if 'regression' in task:\r\n self.estimator_class = xgb.XGBRegressor\r\n else:\r\n self.estimator_class = xgb.XGBClassifier\r\n self._time_per_iter = None\r\n self._train_size = 0\r\n\r\n def fit(self, X_train, y_train, budget=None, kwargs):\r\n if issparse(X_train):\r\n self.params['tree_method'] = 'auto'\r\n return super().fit(X_train, y_train, budget, kwargs)\r\n \r\n\r\nclass RandomForestEstimator(SKLearnEstimator, LGBMEstimator):\r\n\r\n\r\n @classmethod\r\n def search_space(cls, data_size, task, params): \r\n upper = min(2048, int(data_size))\r\n space = {\r\n 'n_estimators': {\r\n 'domain': tune.qloguniform(lower=4, upper=upper, q=1),\r\n 'init_value': 4,\r\n },\r\n 'max_features': {\r\n 'domain': tune.loguniform(lower=0.1, upper=1.0),\r\n 'init_value': 1.0,\r\n },\r\n }\r\n if task != 'regression':\r\n space['criterion'] = {\r\n 'domain': tune.choice(['gini', 'entropy']),\r\n # 'init_value': 'gini',\r\n }\r\n return space\r\n\r\n @classmethod\r\n def size(cls, config):\r\n return 1.0\r\n\r\n @classmethod\r\n def cost_relative2lgbm(cls):\r\n return 2.0\r\n\r\n def __init__(self, task = 'binary:logistic', n_jobs = 1,\r\n n_estimators = 4, max_features = 1.0, criterion = 'gini', params):\r\n super().__init__(task, params)\r\n self.params = {\r\n \"n_estimators\": int(round(n_estimators)),\r\n \"n_jobs\": n_jobs,\r\n 'max_features': float(max_features),\r\n }\r\n if 'regression' in task:\r\n self.estimator_class = RandomForestRegressor\r\n else:\r\n self.estimator_class = RandomForestClassifier\r\n self.params['criterion'] = criterion\r\n self._time_per_iter = None\r\n self._train_size = 0\r\n\r\n def get_params(self, deep=False):\r\n params = super().get_params()\r\n params[\"criterion\"] = 1 if params[\"criterion\"]=='gini' else 2\r\n return params\r\n\r\n\r\nclass ExtraTreeEstimator(RandomForestEstimator):\r\n\r\n\r\n @classmethod\r\n def cost_relative2lgbm(cls):\r\n return 1.9\r\n\r\n def __init__(self, task = 'binary:logistic', params):\r\n super().__init__(task, params)\r\n if 'regression' in task:\r\n self.estimator_class = ExtraTreesRegressor\r\n else:\r\n self.estimator_class = ExtraTreesClassifier\r\n\r\n\r\nclass LRL1Classifier(SKLearnEstimator):\r\n\r\n\r\n @classmethod\r\n def search_space(cls, params): \r\n return {\r\n 'C': {\r\n 'domain': tune.loguniform(lower=0.03125, upper=32768.0),\r\n 'init_value': 1.0,\r\n },\r\n }\r\n\r\n @classmethod\r\n def cost_relative2lgbm(cls):\r\n return 160\r\n\r\n def __init__(self, task='binary:logistic', n_jobs=1, tol=0.0001, C=1.0, \r\n params):\r\n super().__init__(task, params)\r\n self.params = {\r\n 'penalty': 'l1',\r\n 'tol': float(tol),\r\n 'C': float(C),\r\n 'solver': 'saga',\r\n 'n_jobs': n_jobs,\r\n }\r\n if 'regression' in task:\r\n self.estimator_class = None\r\n print('LR does not support regression task')\r\n raise NotImplementedError\r\n else:\r\n self.estimator_class = LogisticRegression\r\n\r\n\r\nclass LRL2Classifier(SKLearnEstimator):\r\n\r\n\r\n @classmethod\r\n def search_space(cls, params): \r\n return LRL1Classifier.search_space(params)\r\n\r\n @classmethod\r\n def cost_relative2lgbm(cls):\r\n return 25\r\n\r\n def __init__(self, task='binary:logistic', n_jobs=1, tol=0.0001, C=1.0, \r\n params):\r\n super().__init__(task, params)\r\n self.params = {\r\n 'penalty': 'l2',\r\n 'tol': float(tol),\r\n 'C': float(C),\r\n 'solver': 'lbfgs',\r\n 'n_jobs': n_jobs,\r\n }\r\n if 'regression' in task:\r\n self.estimator_class = None\r\n print('LR does not support regression task')\r\n raise NotImplementedError\r\n else:\r\n self.estimator_class = LogisticRegression\r\n\r\n\r\nclass CatBoostEstimator(BaseEstimator):\r\n\r\n\r\n _time_per_iter = None\r\n _train_size = 0\r\n\r\n @classmethod\r\n def search_space(cls, data_size, params): \r\n upper = max(min(round(1500000/data_size),150), 11)\r\n return {\r\n 'early_stopping_rounds': {\r\n 'domain': tune.qloguniform(lower=10, upper=upper, q=1),\r\n 'init_value': 10,\r\n },\r\n 'learning_rate': {\r\n 'domain': tune.loguniform(lower=.005, upper=.2),\r\n 'init_value': 0.1,\r\n },\r\n }\r\n\r\n @classmethod\r\n def size(cls, config):\r\n n_estimators = 8192\r\n max_leaves = 64\r\n return (max_leaves3 + (max_leaves-1)4 + 1.0)n_estimators8\r\n\r\n @classmethod\r\n def cost_relative2lgbm(cls):\r\n return 15\r\n\r\n def __init__(self, task = 'binary:logistic', n_jobs=1,\r\n n_estimators=8192, learning_rate=0.1, early_stopping_rounds=4, params):\r\n super().__init__(task, params)\r\n self.params = {\r\n \"early_stopping_rounds\": int(round(early_stopping_rounds)),\r\n \"n_estimators\": n_estimators, \r\n 'learning_rate': learning_rate,\r\n 'thread_count': n_jobs,\r\n 'verbose': False,\r\n 'random_seed': params[\r\n \"random_seed\"] if \"random_seed\" in params else 10242048,\r\n }\r\n if 'regression' in task:\r\n from catboost import CatBoostRegressor\r\n self.estimator_class = CatBoostRegressor\r\n else:\r\n from catboost import CatBoostClassifier\r\n self.estimator_class = CatBoostClassifier\r\n\r\n def get_params(self, deep=False):\r\n params = super().get_params()\r\n params['n_jobs'] = params['thread_count']\r\n return params\r\n\r\n def fit(self, X_train, y_train, budget=None, kwargs):\r\n start_time = time.time()\r\n n_iter = self.params[\"n_estimators\"]\r\n if isinstance(X_train, pd.DataFrame):\r\n cat_features = list(X_train.select_dtypes(\r\n include='category').columns)\r\n else:\r\n cat_features = []\r\n if (not CatBoostEstimator._time_per_iter or\r\n abs(CatBoostEstimator._train_size-len(y_train))>4) and budget:\r\n # measure the time per iteration\r\n self.params[\"n_estimators\"] = 1\r\n CatBoostEstimator._smallmodel = self.estimator_class(self.params)\r\n CatBoostEstimator._smallmodel.fit(X_train, y_train,\r\n cat_features=cat_features, kwargs)\r\n CatBoostEstimator._t1 = time.time() - start_time\r\n if CatBoostEstimator._t1 >= budget: \r\n self.params[\"n_estimators\"] = n_iter\r\n self._model = CatBoostEstimator._smallmodel\r\n return CatBoostEstimator._t1\r\n self.params[\"n_estimators\"] = 4\r\n CatBoostEstimator._smallmodel = self.estimator_class(self.params)\r\n CatBoostEstimator._smallmodel.fit(X_train, y_train,\r\n cat_features=cat_features, kwargs)\r\n CatBoostEstimator._time_per_iter = (time.time() - start_time -\r\n CatBoostEstimator._t1)/(self.params[\"n_estimators\"]-1)\r\n if CatBoostEstimator._time_per_iter <= 0: \r\n CatBoostEstimator._time_per_iter = CatBoostEstimator._t1\r\n CatBoostEstimator._train_size = len(y_train)\r\n if time.time()-start_time>=budget or n_iter==self.params[\r\n \"n_estimators\"]: \r\n self.params[\"n_estimators\"] = n_iter\r\n self._model = CatBoostEstimator._smallmodel\r\n return time.time()-start_time\r\n if budget:\r\n train_times = 1 \r\n self.params[\"n_estimators\"] = min(n_iter, int((budget-time.time()+\r\n start_time-CatBoostEstimator._t1)/train_times/\r\n CatBoostEstimator._time_per_iter+1))\r\n self._model = CatBoostEstimator._smallmodel\r\n if self.params[\"n_estimators\"] > 0:\r\n l = max(int(len(y_train)0.9), len(y_train)-1000)\r\n X_tr, y_tr = X_train[:l], y_train[:l]\r\n if 'sample_weight' in kwargs:\r\n weight = kwargs['sample_weight']\r\n if weight is not None: kwargs['sample_weight'] = weight[:l]\r\n else: weight = None\r\n from catboost import Pool\r\n model = self.estimator_class(self.params)\r\n model.fit(X_tr, y_tr, cat_features=cat_features, eval_set=Pool(\r\n data=X_train[l:], label=y_train[l:], cat_features=cat_features),\r\n kwargs)\r\n if weight is not None: kwargs['sample_weight'] = weight \r\n # print(self.params[\"n_estimators\"], model.get_best_iteration())\r\n self._model = model\r\n self.params[\"n_estimators\"] = n_iter\r\n train_time = time.time() - start_time\r\n # print(budget, train_time)\r\n return train_time\r\n\r\n\r\nclass KNeighborsEstimator(BaseEstimator):\r\n\r\n \r\n @classmethod\r\n def search_space(cls, data_size, params): \r\n upper = min(512, int(data_size/2))\r\n return {\r\n 'n_neighbors': {\r\n 'domain': tune.qloguniform(lower=1, upper=upper, q=1),\r\n 'init_value': 5,\r\n },\r\n }\r\n\r\n @classmethod\r\n def cost_relative2lgbm(cls):\r\n return 30\r\n\r\n def __init__(self, task='binary:logistic', n_jobs=1,\r\n n_neighbors=5, params):\r\n super().__init__(task, **params)\r\n self.params= {\r\n 'n_neighbors': int(round(n_neighbors)),\r\n 'weights': 'distance',\r\n 'n_jobs': n_jobs,\r\n }\r\n if 'regression' in task:\r\n from sklearn.neighbors import KNeighborsRegressor\r\n self.estimator_class = KNeighborsRegressor\r\n else:\r\n from sklearn.neighbors import KNeighborsClassifier\r\n self.estimator_class = KNeighborsClassifier\r\n\r\n def _preprocess(self, X):\r\n if isinstance(X, pd.DataFrame):\r\n cat_columns = X.select_dtypes(['category']).columns\r\n # print(X.dtypes)\r\n # print(cat_columns)\r\n if X.shape[1] == len(cat_columns):\r\n raise ValueError(\r\n \"kneighbor requires at least one numeric feature\")\r\n X = X.drop(cat_columns, axis=1) \r\n return X\r\n" ]	[ [ "numpy.issubdtype", "scipy.sparse.issparse" ] ]
haiderstats/survival_evaluation	[ "70e3a4d530a61549609689e3ebd80818f3ab14d9" ]	[ "survival_evaluation/evaluations.py" ]	[ "from typing import Optional\n\nimport numpy as np # type: ignore\nfrom scipy.stats import chi2 # type: ignore\n\nfrom survival_evaluation.types import NumericArrayLike\nfrom survival_evaluation.utility import (\n KaplanMeier,\n KaplanMeierArea,\n to_array,\n validate_size,\n)\n\n\n# pylint: disable=too-many-arguments\ndef l1(\n event_times: NumericArrayLike,\n event_indicators: NumericArrayLike,\n predictions: NumericArrayLike,\n training_event_times: Optional[NumericArrayLike] = None,\n training_event_indicators: Optional[NumericArrayLike] = None,\n l1_type: str = \"hinge\",\n) -> float:\n\n event_times = to_array(event_times)\n event_indicators = to_array(event_indicators, to_boolean=True)\n predictions = to_array(predictions)\n\n validate_size(event_times, event_indicators, predictions)\n if l1_type == \"hinge\":\n scores = event_times - predictions\n scores[~event_indicators] = np.maximum(scores[~event_indicators], 0)\n return np.mean(np.abs(scores))\n\n if l1_type == \"margin\":\n if training_event_times is None or training_event_indicators is None:\n raise ValueError(\n \"If 'margin' is chosen, training set values must be included.\"\n )\n\n training_event_times = to_array(training_event_times)\n training_event_indicators = to_array(training_event_indicators, to_boolean=True)\n\n km_model = KaplanMeierArea(training_event_times, training_event_indicators)\n censor_times = event_times[~event_indicators]\n weights = 1 - km_model.predict(censor_times)\n best_guesses = km_model.best_guess(censor_times)\n\n scores = np.empty(predictions.size)\n scores[event_indicators] = (\n event_times[event_indicators] - predictions[event_indicators]\n )\n scores[~event_indicators] = weights * (\n best_guesses - predictions[~event_indicators]\n )\n weighted_multiplier = 1 / (np.sum(event_indicators) + np.sum(weights))\n return weighted_multiplier * np.sum(np.abs(scores))\n\n raise ValueError(\"L1 type must be either 'hinge' or 'margin'.\")\n\n\n# pylint: disable=too-many-arguments\n# pylint: disable=too-many-locals\ndef one_calibration(\n event_times: NumericArrayLike,\n event_indicators: NumericArrayLike,\n predictions: NumericArrayLike,\n time: float,\n bins: int = 10,\n) -> dict:\n\n event_times = to_array(event_times)\n event_indicators = to_array(event_indicators, to_boolean=True)\n predictions = 1 - to_array(predictions)\n\n prediction_order = np.argsort(-predictions)\n predictions = predictions[prediction_order]\n event_times = event_times[prediction_order]\n event_indicators = event_indicators[prediction_order]\n\n # Can't do np.mean since split array may be of different sizes.\n binned_event_times = np.array_split(event_times, bins)\n binned_event_indicators = np.array_split(event_indicators, bins)\n probability_means = [np.mean(x) for x in np.array_split(predictions, bins)]\n hosmer_lemeshow = 0\n observed_probabilities = list()\n expected_probabilities = list()\n for b in range(bins):\n prob = probability_means[b]\n if prob == 1.0:\n raise ValueError(\n \"One-Calibration is not well defined: the risk\"\n f\"probability of the {b}th bin was {prob}.\"\n )\n km_model = KaplanMeier(binned_event_times[b], binned_event_indicators[b])\n event_probability = 1 - km_model.predict(time)\n bin_count = len(binned_event_times[b])\n hosmer_lemeshow += (bin_count * event_probability - bin_count * prob) ** 2 / (\n bin_count * prob * (1 - prob)\n )\n observed_probabilities.append(event_probability)\n expected_probabilities.append(prob)\n\n return dict(\n p_value=1 - chi2.cdf(hosmer_lemeshow, bins - 1),\n observed=observed_probabilities,\n expected=expected_probabilities,\n )\n\n\ndef d_calibration(\n event_indicators: NumericArrayLike,\n predictions: NumericArrayLike,\n bins: int = 10,\n) -> dict:\n\n event_indicators = to_array(event_indicators, to_boolean=True)\n predictions = to_array(predictions)\n\n # include minimum to catch if probability = 1.\n bin_index = np.minimum(np.floor(predictions * bins), bins - 1).astype(int)\n censored_bin_indexes = bin_index[~event_indicators]\n uncensored_bin_indexes = bin_index[event_indicators]\n\n censored_predictions = predictions[~event_indicators]\n censored_contribution = 1 - (censored_bin_indexes / bins) * (\n 1 / censored_predictions\n )\n censored_following_contribution = 1 / (bins * censored_predictions)\n\n contribution_pattern = np.tril(np.ones([bins, bins]), k=-1).astype(bool)\n\n following_contributions = np.matmul(\n censored_following_contribution, contribution_pattern[censored_bin_indexes]\n )\n single_contributions = np.matmul(\n censored_contribution, np.eye(bins)[censored_bin_indexes]\n )\n uncensored_contributions = np.sum(np.eye(bins)[uncensored_bin_indexes], axis=0)\n bin_count = (\n single_contributions + following_contributions + uncensored_contributions\n )\n chi2_statistic = np.sum(\n np.square(bin_count - len(predictions) / bins) / (len(predictions) / bins)\n )\n return dict(\n p_value=1 - chi2.cdf(chi2_statistic, bins - 1),\n bin_proportions=bin_count / len(predictions),\n censored_contributions=(single_contributions + following_contributions)\n / len(predictions),\n uncensored_contributions=uncensored_contributions / len(predictions),\n )\n" ]	[ [ "numpy.maximum", "numpy.abs", "numpy.eye", "numpy.matmul", "scipy.stats.chi2.cdf", "numpy.ones", "numpy.mean", "numpy.floor", "numpy.argsort", "numpy.array_split", "numpy.sum", "numpy.empty" ] ]
yukyeongleee/CodeTemplate	[ "d0777d501bf64b01ea63787c75b505f7b76ebeda" ]	[ "submodel/resnet.py" ]	[ "import torch.nn as nn\nimport torch.nn.functional as F\nimport torch.utils.model_zoo as modelzoo\nfrom lib.utils import conv3x3\n\n\nresnet18_url = 'https://download.pytorch.org/models/resnet18-5c106cde.pth'\n\n\nclass Resnet18(nn.Module):\n def __init__(self):\n super(Resnet18, self).__init__()\n self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,\n bias=False)\n self.bn1 = nn.BatchNorm2d(64)\n self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n self.layer1 = create_layer_basic(64, 64, bnum=2, stride=1)\n self.layer2 = create_layer_basic(64, 128, bnum=2, stride=2)\n self.layer3 = create_layer_basic(128, 256, bnum=2, stride=2)\n self.layer4 = create_layer_basic(256, 512, bnum=2, stride=2)\n self.init_weight()\n\n def forward(self, x):\n x = self.conv1(x)\n x = F.relu(self.bn1(x))\n x = self.maxpool(x)\n\n x = self.layer1(x)\n feat8 = self.layer2(x) # 1/8\n feat16 = self.layer3(feat8) # 1/16\n feat32 = self.layer4(feat16) # 1/32\n return feat8, feat16, feat32\n\n def init_weight(self):\n state_dict = modelzoo.load_url(resnet18_url)\n self_state_dict = self.state_dict()\n for k, v in state_dict.items():\n if 'fc' in k: continue\n self_state_dict.update({k: v})\n self.load_state_dict(self_state_dict)\n\n def get_params(self):\n wd_params, nowd_params = [], []\n for module in self.named_modules():\n if isinstance(module, (nn.Linear, nn.Conv2d)):\n wd_params.append(module.weight)\n if not module.bias is None:\n nowd_params.append(module.bias)\n elif isinstance(module, nn.BatchNorm2d):\n nowd_params += list(module.parameters())\n return wd_params, nowd_params\n\n\nclass BasicBlock(nn.Module):\n def __init__(self, in_chan, out_chan, stride=1):\n super(BasicBlock, self).__init__()\n self.conv1 = conv3x3(in_chan, out_chan, stride)\n self.bn1 = nn.BatchNorm2d(out_chan)\n self.conv2 = conv3x3(out_chan, out_chan)\n self.bn2 = nn.BatchNorm2d(out_chan)\n self.relu = nn.ReLU(inplace=True)\n self.downsample = None\n if in_chan != out_chan or stride != 1:\n self.downsample = nn.Sequential(\n nn.Conv2d(in_chan, out_chan,\n kernel_size=1, stride=stride, bias=False),\n nn.BatchNorm2d(out_chan),\n )\n\n def forward(self, x):\n residual = self.conv1(x)\n residual = F.relu(self.bn1(residual))\n residual = self.conv2(residual)\n residual = self.bn2(residual)\n\n shortcut = x\n if self.downsample is not None:\n shortcut = self.downsample(x)\n\n out = shortcut + residual\n out = self.relu(out)\n return out\n\n\ndef create_layer_basic(in_chan, out_chan, bnum, stride=1):\n layers = [BasicBlock(in_chan, out_chan, stride=stride)]\n for i in range(bnum-1):\n layers.append(BasicBlock(out_chan, out_chan, stride=1))\n return nn.Sequential(*layers)\n" ]	[ [ "torch.nn.Sequential", "torch.nn.Conv2d", "torch.nn.MaxPool2d", "torch.nn.BatchNorm2d", "torch.nn.ReLU", "torch.utils.model_zoo.load_url" ] ]
ma-kast/AMfe	[ "99686cc313fb8904a093fb42e6cf0b38f8cfd791" ]	[ "amfe/mor/hyper_red/ecsw.py" ]	[ "\"\"\"\nTODO: Write introduction to ECSW\n\"\"\"\n\nimport logging\n\nimport numpy as np\nfrom scipy.linalg import solve as linsolve\nfrom scipy.sparse import csc_matrix\n\nfrom .ecsw_assembly import EcswAssembly\n\n\n__all__ = ['sparse_nnls',\n 'ecsw_assemble_G_and_b',\n 'ecsw_get_weights_by_component',\n 'EcswAssembly']\n\n\ndef sparse_nnls(G, b, tau, conv_stats=True):\n r\"\"\"\n Run the sparse NNLS-solver in order to find a sparse vector xi satisfying\n\n .. math::\n \|\| G \\xi - b \|\|_2 \\leq \\tau \|\|b\|\|_2 \\quad\\text{with}\\quad \\min\|\|\\xi\|\|_0\n\n Parameters\n ----------\n G : ndarray, shape: (nm, no_of_elements)\n force contribution matrix\n b : ndarray, shape: (nm)\n force contribution vector\n tau : float\n tolerance\n conv_stats : bool\n Flag for setting, that more detailed output is produced with\n convergence information.\n\n Returns\n -------\n x : csc_matrix\n sparse vector containing the weights\n stats : ndarray\n Infos about the convergence of the system. The first column shows the\n size of the active set, the second column the residual. If conv_info is\n set to False, an empty array is returned.\n\n References\n ----------\n .. [1] C. L. Lawson and R. J. Hanson. Solving least squares problems,\n volume 15. SIAM, 1995.\n\n .. [2] T. Chapman, P. Avery, P. Collins, and C. Farhat. Accelerated mesh\n sampling for the hyper reduction of nonlinear computational models.\n International Journal for Numerical Methods in Engineering, 2016.\n\n \"\"\"\n no_of_elements = G.shape[1]\n norm_b = np.linalg.norm(b)\n r = b\n\n xi = np.zeros(no_of_elements) # the resulting vector\n zeta = np.zeros(no_of_elements) # the trial vector which is iterated over\n\n # Boolean active set; allows quick and easys indexing through masking with\n # high performance at the same time\n active_set = np.zeros(no_of_elements, dtype=bool)\n\n stats = []\n while np.linalg.norm(r) > tau * norm_b:\n mu = G.T @ r\n idx = np.argmax(mu)\n if active_set[idx] == True:\n raise RuntimeError('snnls: The index has {} has already been added and is considered to be the best again.')\n active_set[idx] = True\n print('Added element {}'.format(idx))\n while True:\n # Trial vector zeta is solved for the sparse solution\n zeta[~active_set] = 0.0\n G_red = G[:, active_set]\n zeta[active_set] = linsolve(G_red.T @ G_red, G_red.T @ b)\n\n # check, if gathered solution is full positive\n if np.min(zeta[active_set]) >= 0.0:\n xi[:] = zeta[:]\n break\n # remove the negative elements from the active set\n # Get all elements which violate the constraint, i.e. are in the\n # active set and are smaller than zero\n mask = np.logical_and(zeta <= 0.0, active_set)\n\n ele_const = np.argmin(xi[mask] / (xi[mask] - zeta[mask]))\n const_idx = np.where(mask)[0][ele_const]\n print('Remove element {} '.format(const_idx) +\n 'violating the constraint.')\n # Amplify xi with the difference of zeta and xi such, that the\n # largest mismatching negative point becomes zero.\n alpha = np.min(xi[mask] / (xi[mask] - zeta[mask]))\n xi += alpha * (zeta - xi)\n # Set active set manually as otherwise floating point roundoff\n # errors are not considered.\n # active_set = xi != 0\n active_set[const_idx] = False\n\n r = b - G[:, active_set] @ xi[active_set]\n logger = logging.getLogger('amfe.hyper_red.ecsw.snnls')\n logger.debug(\"snnls: residual {} No of active elements: {}\".format(np.linalg.norm(r), len(np.where(xi)[0])))\n if conv_stats:\n stats.append((len(np.where(xi)[0]), np.linalg.norm(r)))\n\n # sp.optimize.nnls(A, b)\n indices = np.where(xi)[0] # remove the nasty tuple from np.where()\n xi_red = xi[active_set]\n indptr = np.array([0, len(xi_red)])\n x = csc_matrix((xi_red, indices, indptr), shape=(G.shape[1], 1))\n if conv_stats and not stats:\n stats.append((0, np.linalg.norm(r)))\n stats = np.array(stats)\n return x, stats\n\n\ndef ecsw_assemble_G_and_b(component, S, W, timesteps=None):\n \"\"\"\n Assembles the element contribution matrix G for the given snapshots S.\n\n This function is needed for cubature bases Hyper reduction methods\n like the ECSW.\n\n Parameters\n ----------\n component : amfe.MeshComponent\n amfe.Component, if a reduction basis should be used, it should already\n be the component that is reduced by this reduction basis\n S : ndarray, shape (no_of_dofs, no_of_snapshots)\n Snapshots gathered as column vectors.\n W : ndarray\n projection matrix\n timesteps : ndarray, shape(no_of_snapshots)\n the timesteps of where the snapshots have been generated can be passed,\n this is important for systems with certain constraints\n\n Returns\n -------\n G : ndarray, shape (nm, no_of_elements)\n Contribution matrix of internal forces. The columns form the\n internal force contributions on the basis V for the m snapshots\n gathered in S.\n b : ndarray, shape (nm, )\n summed force contribution\n\n Note\n ----\n This assembly works on constrained variables\n \"\"\"\n # Check the raw dimension\n # Currently not applicable\n # assert(component.no_of_dofs == S.shape[0])\n\n logger = logging.getLogger('amfe.hyper_red.ecsw.ecsw_assemble_G_and_b')\n\n if timesteps is None:\n timesteps = np.zeros(S.shape[1], dtype=float)\n\n no_of_dofs, no_of_snapshots = S.shape\n no_of_reduced_dofs = W.shape[1]\n\n no_of_elements = component.no_of_elements\n logger.info('Start building large selection matrix G. In total {0:d} elements are treated:'.format(\n no_of_elements))\n\n G = np.zeros((no_of_reduced_dofsno_of_snapshots, no_of_elements))\n\n # Temporarily replace Assembly of component:\n old_assembly = component.assembly\n g_assembly = EcswAssembly([], [])\n component.assembly = g_assembly\n\n # Weight only one element by one\n g_assembly.weights = [1.0]\n\n # Set dq and ddq = 0\n dq = np.zeros(no_of_dofs)\n\n # loop over all elements\n for element_no in range(no_of_elements):\n # Change nonzero weighted elements to current element\n g_assembly.indices = [element_no]\n\n logger.debug('Assemble element {:10d} / {:10d}'.format(element_no+1, no_of_elements))\n # loop over all snapshots\n\n for snapshot_number, (snapshot_vector, t) in enumerate(zip(S.T, timesteps)):\n G[snapshot_numberno_of_reduced_dofs:(snapshot_number+1)*no_of_reduced_dofs, element_no] = W.T @ component.f_int(snapshot_vector,\n dq, t)\n\n b = np.sum(G, axis=1)\n\n # reset assembly\n component.assembly = old_assembly\n return G, b\n\n\ndef ecsw_get_weights_by_component(component, S, W, timesteps=None, tau=0.001, conv_stats=True):\n \"\"\"\n Reduce the given MeshComponent\n\n Parameters\n ----------\n component : instance of MeshComponent\n MeshComponent\n S : ndarray, shape (no_of_dofs, no_of_snapshots)\n Snapshots\n W : ndarray\n projection basis\n timesteps : ndarray, optional\n timesteps of the training snapshots\n if None, all timesteps will be set to zero\n tau : float\n tolerance of the ECSW reduction\n conv_stats : bool\n Flag if conv_stats shall be collected\n\n Returns\n -------\n weights : ndarray\n ecsw weights\n indices : ndarray\n row based indices of elements that have non-zero weights\n stats : ndarray\n convergence stats of the snnls solver\n \"\"\"\n\n if timesteps is None:\n timesteps = np.zeros(S.shape[1], dtype=float)\n\n # Create G and b from snapshots:\n G, b = ecsw_assemble_G_and_b(component, S, W, timesteps)\n\n weights, indices, stats = ecsw_get_weights_by_G_and_b(G, b, tau, conv_stats)\n\n return weights, indices, stats\n\n\ndef ecsw_get_weights_by_G_and_b(G, b, tau, conv_stats):\n # Calculate indices and weights\n x, stats = sparse_nnls(G, b, tau, conv_stats)\n indices = x.indices\n weights = x.data\n\n return weights, indices, stats\n" ]	[ [ "scipy.sparse.csc_matrix", "numpy.logical_and", "numpy.min", "numpy.linalg.norm", "scipy.linalg.solve", "numpy.argmax", "numpy.where", "numpy.argmin", "numpy.array", "numpy.zeros", "numpy.sum" ] ]
neurophysik/jitcdde	[ "44d7ed6ad187d3591407155b6eeb063f73e462cd", "44d7ed6ad187d3591407155b6eeb063f73e462cd", "44d7ed6ad187d3591407155b6eeb063f73e462cd" ]	[ "tests/test_lyaps.py", "examples/two_Roesslers.py", "tests/test_past.py" ]	[ "#!/usr/bin/python3\n# -- coding: utf-8 --\n\n\nimport platform\nimport unittest\nimport numpy as np\nfrom scipy.stats import sem\nfrom jitcdde import t, y, jitcdde_lyap\n\nif platform.system() == \"Windows\":\n\tcompile_args = None\nelse:\n\tfrom jitcxde_common import DEFAULT_COMPILE_ARGS\n\tcompile_args = DEFAULT_COMPILE_ARGS+[\"-g\",\"-UNDEBUG\"]\n\nomega = np.array([0.88167179, 0.87768425])\ndelay = 4.5\n\nf = [\n\tomega[0] * (-y(1) - y(2)),\n\tomega[0] * (y(0) + 0.165 * y(1)),\n\tomega[0] * (0.2 + y(2) * (y(0) - 10.0)),\n\tomega[1] * (-y(4) - y(5)) + 0.25 * (y(0,t-delay) - y(3)),\n\tomega[1] * (y(3) + 0.165 * y(4)),\n\tomega[1] * (0.2 + y(5) * (y(3) - 10.0))\n\t]\n\ntest_parameters = {\n\t\"rtol\": 1e-7,\n\t\"atol\": 1e-7,\n\t\"pws_rtol\": 1e-3,\n\t\"pws_atol\": 1e-3,\n\t\"first_step\": 30,\n\t\"max_step\": 100,\n\t\"min_step\": 1e-30,\n\t}\n\nlyap_controls = [0.0806, 0, -0.0368, -0.1184]\n\nclass TestIntegration(unittest.TestCase):\n\tdef setUp(self):\n\t\tself.DDE = jitcdde_lyap(f, n_lyap=len(lyap_controls))\n\t\tself.DDE.add_past_point(-delay, np.random.random(6), np.random.random(6))\n\t\tself.DDE.add_past_point(0.0, np.random.random(6), np.random.random(6))\n\t\tself.DDE.set_integration_parameters(*test_parameters)\n\t\n\tdef test_integrate_blindly(self):\n\t\tself.DDE.integrate_blindly(100.0, 0.1)\n\t\n\tdef test_step_on_discontinuities(self):\n\t\tself.DDE.step_on_discontinuities()\n\t\n\t## Takes forever:\n\t# def test_Python_core(self):\n\t# \tself.DDE.generate_lambdas(simplify=False)\n\t# \tself.DDE.step_on_discontinuities(max_step=0.1)\n\t\n\tdef tearDown(self):\n\t\tlyaps = []\n\t\tweights = []\n\t\tfor T in np.arange(self.DDE.t, self.DDE.t+1000, 10):\n\t\t\t_, lyap, weight = self.DDE.integrate(T)\n\t\t\tlyaps.append(lyap)\n\t\t\tweights.append(weight)\n\t\tlyaps = np.vstack(lyaps)\n\t\t\n\t\tlyap_start = 40\n\t\tfor i,lyap_control in enumerate(lyap_controls):\n\t\t\tlyap = np.average(lyaps[lyap_start:,i], weights=weights[lyap_start:])\n\t\t\tstderr = sem(lyaps[lyap_start:,i])\n\t\t\tself.assertAlmostEqual(lyap_control, lyap, delta=3stderr)\n\nclass TestSaveAndLoad(TestIntegration):\n\tdef setUp(self):\n\t\tDDE_orig = jitcdde_lyap(f, n_lyap=len(lyap_controls))\n\t\tfilename = DDE_orig.save_compiled(overwrite=True)\n\t\tself.DDE = jitcdde_lyap(\n\t\t\tn=6,\n\t\t\tmodule_location=filename,\n\t\t\tdelays=[delay],\n\t\t\tn_lyap=len(lyap_controls)\n\t\t\t)\n\t\tself.DDE.add_past_point(-delay, np.random.random(6), np.random.random(6))\n\t\tself.DDE.add_past_point(0.0, np.random.random(6), np.random.random(6))\n\t\tself.DDE.set_integration_parameters(test_parameters)\n\nclass TestOMP(TestIntegration):\n\tdef setUp(self):\n\t\tself.DDE = jitcdde_lyap(f, n_lyap=len(lyap_controls))\n\t\tself.DDE.add_past_point(-delay, np.random.random(6), np.random.random(6))\n\t\tself.DDE.add_past_point(0.0, np.random.random(6), np.random.random(6))\n\t\tself.DDE.set_integration_parameters(test_parameters)\n\t\tself.DDE.compile_C(omp=True,chunk_size=15)\n\t\nif __name__ == \"__main__\":\n\tunittest.main(buffer=True)\n\n", "from jitcdde import t, y, jitcdde\nimport numpy as np\n\nω = np.random.normal(0.89, 0.0089, 2)\nk = 0.25\ndelay = 4.5\n\nf = [\n\tω[0] * (-y(1) - y(2)),\n\tω[0] * (y(0) + 0.165 * y(1)),\n\tω[0] * (0.2 + y(2) * (y(0) - 10.0)),\n\tω[1] * (-y(4) - y(5)) + k * (y(0,t-delay) - y(3)),\n\tω[1] * (y(3) + 0.165 * y(4)),\n\tω[1] * (0.2 + y(5) * (y(3) - 10.0))\n\t]\n\nDDE = jitcdde(f)\n\nstart_state = np.random.uniform(-0.5,0.5,6)\n\nDDE.add_past_point(-delay, start_state, np.zeros(6))\nDDE.add_past_point(0.0 , start_state, np.zeros(6))\n\nDDE.step_on_discontinuities()\n\ntimes = np.arange(DDE.t,DDE.t+1000,0.1)\ndata = np.vstack([ DDE.integrate(T) for T in times ])\nnp.savetxt(\"two_roesslers.dat\", data)\n\n", "#!/usr/bin/python3\n# -- coding: utf-8 --\n\nfrom jitcdde.past import Past\n\nimport symengine\nimport numpy as np\nfrom numpy.testing import assert_allclose\nimport unittest\n\n\nclass normalisation_test(unittest.TestCase):\n\tdef test_orthonormalisation(self):\n\t\tm = 4\n\t\tpast = Past(n=m,anchors=[\n\t\t\t\t(time, np.random.normal(0,1,m), np.random.normal(0,1,m))\n\t\t\t\tfor time in sorted(np.random.uniform(-3,0,5))\n\t\t\t])\n\t\tdelay = np.random.uniform(0.0,2.0)\n\t\tpast.orthonormalise(m-1, delay)\n\t\t\n\t\tfor j in range(1,m):\n\t\t\tself.assertAlmostEqual(past.norm(delay, j), 1.0)\n\t\t\t\n\t\t\tfor k in range(j,m):\n\t\t\t\tcontrol = 1.0 if k==j else 0.0\n\t\t\t\tsp = past.scalar_product(delay, j, k)\n\t\t\t\tself.assertAlmostEqual(sp, control)\n\nclass remove_projection_test(unittest.TestCase):\n\tdef setUp(self):\n\t\tself.n_basic = 3\n\t\tself.n = 6self.n_basic\n\t\t\n\t\tself.original_past = Past(n=self.n,n_basic=self.n_basic)\n\t\tfor i in range(np.random.randint(3,10)):\n\t\t\tif i==0:\n\t\t\t\ttime = np.random.uniform(-10,10)\n\t\t\telse:\n\t\t\t\ttime = self.original_past[-1][0] + 0.1 + np.random.random()\n\t\t\tstate = np.random.random(self.n)\n\t\t\tdiff = np.random.random(self.n)\n\t\t\tself.original_past.append((time, state, diff))\n\t\t\n\t\tself.past = self.original_past.copy()\n\t\n\tdef test_remove_first_component(self):\n\t\tempty = lambda: np.zeros(self.n_basic)\n\t\tvectors = [\n\t\t\t\t(empty(), empty()),\n\t\t\t\t(empty(), empty())\n\t\t\t]\n\t\tcomponent = np.random.randint(0,self.n_basic)\n\t\tvectors[0][0][component] = 1\n\t\tvectors[1][1][component] = 1\n\t\tdelay = self.original_past[-1][0]-self.original_past[0][0]\n\t\t\n\t\tself.past.remove_projections(delay, vectors)\n\t\tfor anchor in self.past:\n\t\t\tself.assertAlmostEqual(anchor[1][self.n_basic+component], 0.0)\n\t\t\tself.assertAlmostEqual(anchor[2][self.n_basic+component], 0.0)\n\t\n\tdef test_double_removal(self):\n\t\trandom_vector = lambda: np.random.random(self.n_basic)\n\t\tvectors = [\n\t\t\t(random_vector(), random_vector()),\n\t\t\t(random_vector(), random_vector())\n\t\t\t]\n\t\tdelay = (self.original_past[-1][0]-self.original_past[0][0])np.random.uniform(0.5,1.5)\n\t\t\n\t\tself.past.remove_projections(delay, vectors)\n\t\tpast_copy = [(anchor[0], np.copy(anchor[1]), np.copy(anchor[2])) for anchor in self.past]\n\t\tfor anchor_A, anchor_B in zip(past_copy, self.past):\n\t\t\tassert_allclose(anchor_A[1], anchor_B[1])\n\t\t\tassert_allclose(anchor_A[2], anchor_B[2])\n\t\t\n\t\tnorm = self.past.remove_projections(delay, vectors)\n\t\tself.assertAlmostEqual(norm, 1.0)\n\t\t\n\t\tfor anchor_A, anchor_B in zip(past_copy, self.past):\n\t\t\tassert_allclose(anchor_A[1], anchor_B[1])\n\t\t\tassert_allclose(anchor_A[2], anchor_B[2])\n\nif __name__ == \"__main__\":\n\tunittest.main(buffer=True)\n\n" ]	[ [ "numpy.random.random", "numpy.arange", "numpy.average", "scipy.stats.sem", "numpy.array", "numpy.vstack" ], [ "numpy.arange", "numpy.random.normal", "numpy.savetxt", "numpy.random.uniform", "numpy.zeros" ], [ "numpy.random.random", "numpy.copy", "numpy.random.normal", "numpy.testing.assert_allclose", "numpy.random.uniform", "numpy.zeros", "numpy.random.randint" ] ]
arj119/adaptive-federated-learning	[ "6c22d65c3a46a0b293dc5ddd4cd579f6010445f5" ]	[ "control_algorithm/adaptive_tau.py" ]	[ "import math\nimport numpy as np\nfrom numpy import linalg\nfrom util.utils import recv_msg, send_msg, moving_average\nfrom config import tau_max\n\n\nclass ControlAlgAdaptiveTauServer:\n def __init__(self, is_adapt_local, dim_w, client_sock_all, n_nodes, control_param_phi,\n moving_average_holding_param):\n\n self.is_adapt_local = is_adapt_local\n self.dim_w = dim_w\n self.client_sock_all = client_sock_all\n self.n_nodes = n_nodes\n self.control_param_phi = control_param_phi\n self.moving_average_holding_param = moving_average_holding_param\n\n self.beta_adapt_mvaverage = None\n self.delta_adapt_mvaverage = None\n self.rho_adapt_mvaverage = None\n\n def compute_new_tau(self, data_size_local_all, data_size_total, it_each_local, it_each_global, max_time,\n step_size, tau, use_min_loss):\n\n beta_adapt = 0\n delta_adapt = 0\n rho_adapt = 0\n global_grad_global_weight = np.zeros(self.dim_w)\n\n local_grad_global_weight_all = []\n\n control_param_computed = False\n for n in range(0, self.n_nodes):\n msg = recv_msg(self.client_sock_all[n], 'MSG_CONTROL_PARAM_COMPUTED_CLIENT_TO_SERVER')\n # ['MSG_CONTROL_PARAM_COMPUTED_CLIENT_TO_SERVER', control_param_computed]\n control_param_computed_this_client = msg[1] # Boolean parameter specifying whether parameters for\n # control algorithm follows this message\n\n control_param_computed = control_param_computed or control_param_computed_this_client\n\n # Receive additional message for control algorithm if it has been computed\n if control_param_computed_this_client:\n msg = recv_msg(self.client_sock_all[n], 'MSG_BETA_RHO_GRAD_CLIENT_TO_SERVER')\n # ['MSG_BETA_RHO_GRAD_CLIENT_TO_SERVER', betaAdapt, rhoAdapt, localGradGlobalWeight]\n\n beta_adapt_local = msg[1]\n rho_adapt_local = msg[2]\n local_grad_global_weight = msg[3]\n\n local_grad_global_weight_all.append(local_grad_global_weight)\n\n beta_adapt += data_size_local_all[n] * beta_adapt_local\n rho_adapt += data_size_local_all[n] * rho_adapt_local\n global_grad_global_weight += data_size_local_all[n] * local_grad_global_weight\n\n global_grad_global_weight /= data_size_total\n\n if control_param_computed and (it_each_local is not None) and (it_each_global is not None):\n # finalize beta and delta computation when using control algorithm\n beta_adapt /= data_size_total\n rho_adapt /= data_size_total\n\n for i in range(0, self.n_nodes):\n delta_adapt += data_size_local_all[i] * linalg.norm(local_grad_global_weight_all[i]\n - global_grad_global_weight)\n delta_adapt /= data_size_total\n\n # compute moving averages\n self.beta_adapt_mvaverage = moving_average(self.beta_adapt_mvaverage, beta_adapt, self.moving_average_holding_param)\n self.delta_adapt_mvaverage = moving_average(self.delta_adapt_mvaverage, delta_adapt, self.moving_average_holding_param)\n self.rho_adapt_mvaverage = moving_average(self.rho_adapt_mvaverage, rho_adapt, self.moving_average_holding_param)\n\n print('betaAdapt_mvaverage =', self.beta_adapt_mvaverage)\n print('deltaAdapt_mvaverage =', self.delta_adapt_mvaverage)\n print('rhoAdapt_mvaverage =', self.rho_adapt_mvaverage)\n\n # Find tau if using control algorithm\n if self.is_adapt_local:\n\n # Find new optimal tau\n min_tau_new_tmp = 1\n min_val = float('inf')\n\n for tau_new_tmp in range(1, tau * 10 + 1):\n h_tau_tmp = max(0.0, (self.delta_adapt_mvaverage / self.beta_adapt_mvaverage) * (\n np.power(step_size * self.beta_adapt_mvaverage + 1,\n tau_new_tmp) - 1) - self.delta_adapt_mvaverage * step_size * tau_new_tmp)\n\n # The below lines are the new expression, with betaAdapt and rhoAdapt, and additional term of ht\n if use_min_loss:\n tmp_adjusted_T = (max_time - it_each_local - it_each_global) * tau_new_tmp / \\\n (it_each_local * tau_new_tmp + it_each_global)\n else:\n tmp_adjusted_T = max_time * tau_new_tmp / (it_each_local * tau_new_tmp + it_each_global)\n\n tmp_gap = (1 + math.sqrt(max(0.0, 1 + 4 * math.pow(tmp_adjusted_T, 2.0)\n * self.control_param_phi * self.rho_adapt_mvaverage\n * step_size * h_tau_tmp / tau_new_tmp))) / (\n 2 * tmp_adjusted_T * step_size * self.control_param_phi) + self.rho_adapt_mvaverage * h_tau_tmp\n\n if tmp_gap < min_val:\n min_val = tmp_gap\n min_tau_new_tmp = tau_new_tmp\n\n tau_new = min_tau_new_tmp\n else:\n tau_new = tau\n else:\n tau_new = tau\n\n return min(tau_new, tau_max)\n\n def __getstate__(self):\n # To remove socket from pickle\n state = self.__dict__.copy()\n del state['client_sock_all']\n return state\n\n\nclass ControlAlgAdaptiveTauClient:\n def __init__(self):\n self.w_last_local_last_round = None\n self.grad_last_local_last_round = None\n self.loss_last_local_last_round = None\n\n def init_new_round(self, w):\n self.control_param_computed = False\n self.beta_adapt = None\n self.rho_adapt = None\n self.grad_last_global = None\n\n def update_after_each_local(self, iteration_index, w, grad, total_iterations):\n if iteration_index == 0:\n self.grad_last_global = grad\n\n return False\n\n def update_after_all_local(self, model, train_image, train_label, train_indices,\n w, w_last_global, loss_last_global):\n\n # Only compute beta and rho locally, delta can only be computed globally\n if (self.w_last_local_last_round is not None) and (self.grad_last_local_last_round is not None) and \\\n (self.loss_last_local_last_round is not None):\n\n # compute beta\n c = self.grad_last_local_last_round - self.grad_last_global\n tmp_norm = linalg.norm(self.w_last_local_last_round - w_last_global)\n if tmp_norm > 1e-10:\n self.beta_adapt = linalg.norm(c) / tmp_norm\n else:\n self.beta_adapt = 0\n\n # Compute rho\n if tmp_norm > 1e-10:\n self.rho_adapt = linalg.norm(self.loss_last_local_last_round - loss_last_global) / tmp_norm\n else:\n self.rho_adapt = 0\n\n if self.beta_adapt < 1e-5 or np.isnan(self.beta_adapt):\n self.beta_adapt = 1e-5\n\n if np.isnan(self.rho_adapt):\n self.rho_adapt = 0\n\n print('betaAdapt =', self.beta_adapt)\n\n self.control_param_computed = True\n\n self.grad_last_local_last_round = model.gradient(train_image, train_label, w, train_indices)\n\n try:\n self.loss_last_local_last_round = model.loss_from_prev_gradient_computation()\n except: # Will get an exception if the model does not support computing loss from previous gradient computation\n self.loss_last_local_last_round = model.loss(train_image, train_label, w, train_indices)\n\n self.w_last_local_last_round = w\n\n def send_to_server(self, sock):\n\n msg = ['MSG_CONTROL_PARAM_COMPUTED_CLIENT_TO_SERVER', self.control_param_computed]\n send_msg(sock, msg)\n\n if self.control_param_computed:\n msg = ['MSG_BETA_RHO_GRAD_CLIENT_TO_SERVER', self.beta_adapt, self.rho_adapt, self.grad_last_global]\n send_msg(sock, msg)\n\n" ]	[ [ "numpy.isnan", "numpy.zeros", "numpy.linalg.norm", "numpy.power" ] ]
PhilippPelz/scikit-pr-open	[ "50833b13160b6afe0a743d63d560bddeee2c18b5" ]	[ "skpr/nn/_functions/Broadcast.py" ]	[ "import torch as th\nfrom torch.autograd import Function\n\nimport skpr.inout as io\n\n\nclass Broadcast(Function):\n @staticmethod\n def forward(ctx, input, ntimes, divide_by_ntimes=True):\n io.logger.debug('Broadcast forward 1')\n # out = input.clone()\n # print 'Broadcast.forward'\n ctx.ntimes = ntimes\n ctx.divide_by_ntimes = divide_by_ntimes\n io.logger.debug('Broadcast forward 2')\n return input.view(1, input.size()).expand(ntimes, input.size())\n\n @staticmethod\n def backward(ctx, grad_output):\n io.logger.debug('Broadcast backward 1')\n # p.var['dCMul'] = grad_output.data.cpu().squeeze().numpy()\n grad_input = th.sum(grad_output, 0)\n if ctx.divide_by_ntimes:\n grad_input.data.div_(ctx.ntimes)\n # p.var['dP'] = grad_input.data.cpu().numpy()\n io.logger.debug('Broadcast backward 2')\n return grad_input, None, None\n" ]	[ [ "torch.sum" ] ]
k4ntz/XmodRL	[ "dffb416bcd91010d8075ee1ac00cc4b9a3021967" ]	[ "src/xrl/algorithms/minidr/dataset.py" ]	[ "import numpy as np\nimport torch\nfrom torch._C import dtype\nimport torch.nn as nn\nfrom torch.utils.data import Dataset\n\nclass ModelDataset(Dataset):\n def __init__(self, history, history_size):\n self.h = history #history is passed as list and updated outside\n self.history_size = history_size\n\n def __len__(self):\n return self.history_size\n\n def __getitem__(self, idx):\n idx = idx % len(self.h) #do not exceed history length\n episode = self.h[idx]\n\n idx_sample = np.random.randint(0, (len(episode)-1)//4) #sample random part of episode\n\n # one entry is last state, action, state and reward as seperate entries\n last_states = episode[idx_sample * 4]\n actions= episode[idx_sample * 4 + 1]\n states = episode[idx_sample * 4 + 2]\n rewards= episode[idx_sample * 4 + 3]\n\n # flatten raw features list\n last_states = [[0,0] if x==None else x for x in last_states]\n last_states = np.array(np.array(last_states).tolist()).flatten()\n # convert to tensor\n last_states = torch.tensor(last_states).float()\n actions = torch.tensor(actions)\n states = torch.tensor(np.array(states.tolist()).flatten()).float()\n rewards = torch.tensor(rewards)\n\n return last_states, actions, states, rewards" ]	[ [ "numpy.array", "torch.tensor" ] ]
saarimrahman/imagenet-testbed	[ "55a867d091c7193225880010853ed2b4b0b73ec9" ]	[ "plotting/paper_hyp_robust_imagenetv2.py" ]	[ "import os\nfrom os.path import join, exists\nimport argparse\nimport pathlib\nfrom enum import Enum\n\nimport click\nimport numpy as np\nimport pandas as pd\n\nimport download_data\nimport dataframe\nimport plotter\nfrom model_types import ModelTypes, model_types_map\n\n\nclass HypModelTypes(Enum):\n HYP_ROBUST = ('Hypothetical robust model', 'tab:green', 400)\n STANDARD = ('Standard models', 'tab:blue', 150)\n\n\nmodels = [k for k, v in model_types_map.items() if v == ModelTypes.STANDARD]\nmodels = [m for m in models if 'subsample' not in m and 'batch64' not in m and 'aws' not in m]\n\n\ndef get_model_type(df_row):\n if df_row.name in models:\n return HypModelTypes.STANDARD\n\n\ndef show_in_plot(df_row):\n model_name, model_type = df_row.name.lower(), df_row.model_type\n return True\n\n\ndef use_for_line_fit(df_row):\n model_name, model_type, in_plot = df_row.name.lower(), df_row.model_type, df_row.show_in_plot\n return True\n\n\[email protected]()\[email protected]('--x_axis', type=str, default='val')\[email protected]('--y_axis', type=str, default='imagenetv2-matched-frequency-format-val')\[email protected]('--transform', type=str, default='logit')\[email protected]('--output_dir', type=str, default=str((pathlib.Path(__file__).parent / '../outputs').resolve()))\[email protected]('--output_file_dir', type=str, default=str((pathlib.Path(__file__).parent / '../paper/figs').resolve()))\[email protected]('--skip_download', is_flag=True, type=bool)\ndef generate_xy_plot(x_axis, y_axis, transform, output_dir, output_file_dir, skip_download):\n\n if skip_download:\n filename = join(output_dir, 'grid_df.pkl')\n if not exists(filename):\n raise Exception(f'Downloaded data not found at {filename}. Please run python src/plotting/download_data.py first')\n df = pd.read_pickle(filename)\n else:\n df = download_data.download_plotting_data(output_dir, store_data=True, verbose=True)\n\n df, df_metadata = dataframe.extract_metadata(df)\n df, df_metadata = dataframe.replace_10percent_with_metadata(df, df_metadata)\n df, df_metadata = dataframe.aggregate_corruptions_with_metadata(df, df_metadata)\n\n df = prepare_df_for_plotting(df, df_metadata, [x_axis, y_axis])\n df = plotter.add_plotting_data(df, [x_axis, y_axis])\n df = df.dropna()\n\n hyp_robust_model = df.loc['vgg19'].copy()\n arrow_params = (hyp_robust_model['val'], hyp_robust_model['imagenetv2-matched-frequency-format-val']+0.3, 0, 0.285)\n hyp_robust_model.model_type = HypModelTypes.HYP_ROBUST\n hyp_robust_model['imagenetv2-matched-frequency-format-val'] += 8\n hyp_robust_model.name = 'vgg19_hyp_robust'\n hyp_robust_model.use_for_line_fit = False\n df = df.append(hyp_robust_model)\n\n # auto set xlim and ylim based on visible points\n df_visible = df[df.show_in_plot == True]\n xlim = [df_visible[x_axis].min() - 1, df_visible[x_axis].max() + 1]\n ylim = [df_visible[y_axis].min() - 2, df_visible[y_axis].values.max() + 2]\n\n fig, ax = plotter.model_scatter_plot_hyp(df, x_axis, y_axis, xlim, ylim, HypModelTypes, \n transform=transform, tick_multiplier=5,\n title='Hypothetical Robustness Intervention', x_label='ImageNet', y_label='ImageNetV2', \n figsize=(12, 9), include_legend=True, return_separate_legend=False, alpha=0.7, arrow_params=arrow_params)\n\n l = ax.legend(loc='lower right',\n ncol=1,\n bbox_to_anchor=(1, 0),\n fontsize=plotter.legend_fontsize,\n scatterpoints=1,\n columnspacing=0,\n handlelength=1.5,\n borderpad=0.2)\n\n for i, x in enumerate(l.legendHandles):\n x._sizes = [100]\n if i == 2:\n x._sizes = [400]\n\n os.makedirs(output_file_dir, exist_ok=True)\n\n fig.savefig(join(output_file_dir, f'hyp_robust_imagenetv2.pdf'), dpi='figure', bbox_inches='tight', pad_inches=0.1)\n print(f\"Plot saved to {join(output_file_dir, f'hyp_robust_imagenetv2.pdf')}\")\n\n\ndef prepare_df_for_plotting(df, df_metadata, columns):\n assert set(columns).issubset(set(df.columns))\n\n df = df[columns]\n df_metadata = df_metadata[[x+'_dataset_size' for x in columns]]\n df = df.merge(df_metadata, right_index=True, left_index=True)\n df = df.dropna()\n\n df['model_type'] = df.apply(get_model_type, axis=1)\n df['show_in_plot'] = df.apply(show_in_plot, axis=1)\n df['use_for_line_fit'] = df.apply(use_for_line_fit, axis=1)\n\n return df\n\n\nif __name__ == '__main__':\n generate_xy_plot()\n" ]	[ [ "pandas.read_pickle" ] ]
tjingrant/onnx-tf	[ "3412d86238bf99bf4908e829af115693df161988" ]	[ "test/test_model.py" ]	[ "from __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __future__ import unicode_literals\n\nimport unittest\nimport numpy as np\nimport tensorflow as tf\nimport onnx\nfrom onnx_tf.backend import run_node, prepare\nfrom onnx import helper\nfrom onnx.onnx_pb2 import TensorProto\n\nclass TestModel(unittest.TestCase):\n \"\"\" Tests for models\n \"\"\"\n def test_relu_node_inplace(self):\n X = np.random.randn(3, 2).astype(np.float32)\n Y_ref = np.clip(X, 0, np.inf)\n\n node_def = helper.make_node(\n \"Relu\", [\"X\"], [\"X\"])\n\n graph_def = helper.make_graph(\n [node_def],\n name=\"test\",\n inputs=[helper.make_tensor_value_info(\"X\", TensorProto.FLOAT, [3, 2])],\n outputs=[helper.make_tensor_value_info(\"X\", TensorProto.FLOAT, [3, 2])])\n tf_rep = prepare(helper.make_model(graph_def))\n output = tf_rep.run({\"X\": X})\n np.testing.assert_almost_equal(output.X, Y_ref)\n\n def test_initializer(self):\n X = np.array([[1, 2], [3, 4]]).astype(np.float32)\n Y = np.array([[1, 2], [3, 4]]).astype(np.float32)\n weight = np.array([[1, 0], [0, 1]])\n graph_def = helper.make_graph(\n [helper.make_node(\"Add\", [\"X\", \"Y\"], [\"Z0\"]),\n helper.make_node(\"Cast\", [\"Z0\"], [\"Z\"], to=\"float\"),\n helper.make_node(\"Mul\", [\"Z\", \"weight\"], [\"W\"]),\n helper.make_node(\"Tanh\", [\"W\"], [\"W\"]),\n helper.make_node(\"Sigmoid\", [\"W\"], [\"W\"])],\n name=\"test_initializer\",\n inputs=[\n helper.make_tensor_value_info(\"X\", TensorProto.FLOAT, (2, 2)),\n helper.make_tensor_value_info(\"Y\", TensorProto.FLOAT, (2, 2)),\n helper.make_tensor_value_info(\"weight\", TensorProto.FLOAT, (2, 2)),\n ],\n outputs=[\n helper.make_tensor_value_info(\"W\", TensorProto.FLOAT, (2, 2))\n ],\n initializer=[helper.make_tensor(\"weight\",\n TensorProto.FLOAT,\n [2, 2],\n weight.flatten().astype(float))]\n )\n\n def sigmoid(x):\n return 1 / (1 + np.exp(-x))\n\n W_ref = sigmoid(np.tanh((X + Y) * weight))\n tf_rep = prepare(helper.make_model(graph_def))\n output = tf_rep.run({\"X\": X, \"Y\": Y})\n np.testing.assert_almost_equal(output[\"W\"], W_ref)\n\nif __name__ == '__main__':\n unittest.main()\n" ]	[ [ "numpy.clip", "numpy.testing.assert_almost_equal", "numpy.random.randn", "numpy.exp", "numpy.array", "numpy.tanh" ] ]
tien1504/idinvert_pytorch	[ "19999e9945aef4843a464930426a565256863ded" ]	[ "mix_style.py" ]	[ "# python 3.6\n\"\"\"Mixes styles with In-domain GAN Inversion.\n\nThe real images should be first inverted to latent codes with `invert.py`. After\nthat, this script can be used for style mixing.\n\nNOTE: This script will mix every `style-content` image pair from style\ndirectory to content directory.\n\"\"\"\n\nimport os\nimport argparse\nfrom tqdm import tqdm\nimport numpy as np\n\nfrom models.helper import build_generator\nfrom utils.logger import setup_logger\nfrom utils.editor import mix_style\nfrom utils.visualizer import load_image\nfrom utils.visualizer import HtmlPageVisualizer\n\n\ndef parse_args():\n \"\"\"Parses arguments.\"\"\"\n parser = argparse.ArgumentParser()\n parser.add_argument('model_name', type=str, help='Name of the GAN model.')\n parser.add_argument('style_dir', type=str,\n help='Style directory, which includes original images, '\n 'inverted codes, and image list.')\n parser.add_argument('content_dir', type=str,\n help='Content directory, which includes original images, '\n 'inverted codes, and image list.')\n parser.add_argument('-o', '--output_dir', type=str, default='',\n help='Directory to save the results. If not specified, '\n '`./results/style_mixing` will be used by default.')\n parser.add_argument('--mix_layer_start_idx', type=int, default=10,\n help='0-based layer index. Style mixing is performed '\n 'from this layer to the last layer. (default: 10)')\n parser.add_argument('--viz_size', type=int, default=256,\n help='Image size for visualization. (default: 256)')\n parser.add_argument('--gpu_id', type=str, default='0',\n help='Which GPU(s) to use. (default: `0`)')\n return parser.parse_args()\n\n\ndef main():\n \"\"\"Main function.\"\"\"\n args = parse_args()\n os.environ[\"CUDA_VISIBLE_DEVICES\"] = args.gpu_id\n style_dir = args.style_dir\n style_dir_name = os.path.basename(style_dir.rstrip('/'))\n assert os.path.exists(style_dir)\n assert os.path.exists(f'{style_dir}/image_list.txt')\n assert os.path.exists(f'{style_dir}/inverted_codes.npy')\n content_dir = args.content_dir\n content_dir_name = os.path.basename(content_dir.rstrip('/'))\n assert os.path.exists(content_dir)\n assert os.path.exists(f'{content_dir}/image_list.txt')\n assert os.path.exists(f'{content_dir}/inverted_codes.npy')\n output_dir = args.output_dir or 'results/style_mixing'\n job_name = f'{style_dir_name}_STYLIZE_{content_dir_name}'\n logger = setup_logger(output_dir, f'{job_name}.log', f'{job_name}_logger')\n\n # Load model.\n logger.info(f'Loading generator.')\n generator = build_generator(args.model_name)\n mix_layers = list(range(args.mix_layer_start_idx, generator.num_layers))\n\n # Load image and codes.\n logger.info(f'Loading images and corresponding inverted latent codes.')\n style_list = []\n with open(f'{style_dir}/image_list.txt', 'r') as f:\n for line in f:\n name = os.path.splitext(os.path.basename(line.strip()))[0]\n assert os.path.exists(f'{style_dir}/{name}_ori.png')\n style_list.append(name)\n logger.info(f'Loading inverted latent codes.')\n style_codes = np.load(f'{style_dir}/inverted_codes.npy')\n assert style_codes.shape[0] == len(style_list)\n num_styles = style_codes.shape[0]\n content_list = []\n with open(f'{content_dir}/image_list.txt', 'r') as f:\n for line in f:\n name = os.path.splitext(os.path.basename(line.strip()))[0]\n assert os.path.exists(f'{content_dir}/{name}_ori.png')\n content_list.append(name)\n logger.info(f'Loading inverted latent codes.')\n content_codes = np.load(f'{content_dir}/inverted_codes.npy')\n assert content_codes.shape[0] == len(content_list)\n num_contents = content_codes.shape[0]\n\n # Mix styles.\n logger.info(f'Start style mixing.')\n viz_size = None if args.viz_size == 0 else args.viz_size\n visualizer = HtmlPageVisualizer(\n num_rows=num_styles + 1, num_cols=num_contents + 1, viz_size=viz_size)\n visualizer.set_headers(\n ['Style'] +\n [f'Content {i:03d}' for i in range(num_contents)]\n )\n for style_idx, style_name in enumerate(style_list):\n style_image = load_image(f'{style_dir}/{style_name}_ori.png')\n visualizer.set_cell(style_idx + 1, 0, image=style_image)\n for content_idx, content_name in enumerate(content_list):\n content_image = load_image(f'{content_dir}/{content_name}_ori.png')\n visualizer.set_cell(0, content_idx + 1, image=content_image)\n\n codes = mix_style(style_codes=style_codes,\n content_codes=content_codes,\n num_layers=generator.num_layers,\n mix_layers=mix_layers)\n for style_idx in tqdm(range(num_styles), leave=False):\n output_images = generator.easy_synthesize(\n codes[style_idx], latent_space_type='wp')['image']\n for content_idx, output_image in enumerate(output_images):\n visualizer.set_cell(style_idx + 1, content_idx + 1, image=output_image)\n\n # Save results.\n visualizer.save(f'{output_dir}/{job_name}.html')\n\n\nif __name__ == '__main__':\n main()\n" ]	[ [ "numpy.load" ] ]
valeoai/POCO	[ "c6ab56b1b7f01c51d1bc6987eae0a8c79725e63f" ]	[ "lightconvpoint/nn/conv_fkaconv.py" ]	[ "import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom math import ceil\n# from lightconvpoint.spatial import knn, sampling_quantized\nfrom lightconvpoint.utils.functional import batch_gather\nimport torch\n\nclass Convolution_FKAConv(torch.nn.Module):\n\n\n def __init__(self, in_channels, out_channels, kernel_size=16, bias=False, dim=3, kernel_separation=False, adaptive_normalization=True,*kwargs):\n super().__init__()\n\n # parameters\n self.in_channels = in_channels\n self.out_channels = out_channels\n self.kernel_size = kernel_size\n self.bias = bias\n self.dim = dim\n self.adaptive_normalization = adaptive_normalization\n\n # convolution kernel\n if kernel_separation:\n # equivalent to two kernels K1 K2\n dm = int(ceil(self.out_channels / self.in_channels))\n self.cv = nn.Sequential(\n nn.Conv2d(in_channels, dmin_channels, (1, kernel_size), bias=bias, groups=self.in_channels),\n nn.Conv2d(in_channelsdm, out_channels, (1, 1), bias=bias)\n )\n else:\n self.cv = nn.Conv2d(in_channels, out_channels, (1, kernel_size), bias=bias)\n\n # normalization radius\n if self.adaptive_normalization:\n self.norm_radius_momentum = 0.1\n self.norm_radius = nn.Parameter(torch.Tensor(1,), requires_grad=False)\n self.alpha = nn.Parameter(torch.Tensor(1,), requires_grad=True)\n self.beta = nn.Parameter(torch.Tensor(1,), requires_grad=True)\n torch.nn.init.ones_(self.norm_radius.data)\n torch.nn.init.ones_(self.alpha.data)\n torch.nn.init.ones_(self.beta.data)\n\n # features to kernel weights\n self.fc1 = nn.Conv2d(self.dim, self.kernel_size, 1, bias=False)\n self.fc2 = nn.Conv2d(2 * self.kernel_size, self.kernel_size, 1, bias=False)\n self.fc3 = nn.Conv2d(2 * self.kernel_size, self.kernel_size, 1, bias=False)\n self.bn1 = nn.InstanceNorm2d(self.kernel_size, affine=True)\n self.bn2 = nn.InstanceNorm2d(self.kernel_size, affine=True)\n\n\n\n def fixed_normalization(self, pts, radius=None):\n maxi = torch.sqrt((pts.detach() 2).sum(1).max(2)[0])\n maxi = maxi + (maxi == 0)\n return pts / maxi.view(maxi.size(0), 1, maxi.size(1), 1)\n\n\n\n def forward(self, x, pos, support_points, neighbors_indices):\n\n if x is None:\n return None\n\n pos = batch_gather(pos, dim=2, index=neighbors_indices).contiguous()\n x = batch_gather(x, dim=2, index=neighbors_indices).contiguous()\n\n # center the neighborhoods (local coordinates)\n pts = pos - support_points.unsqueeze(3)\n\n\n # normalize points\n if self.adaptive_normalization:\n\n\n # compute distances from points to their support point\n distances = torch.sqrt((pts.detach() 2).sum(1))\n\n # update the normalization radius\n if self.training:\n mean_radius = distances.max(2)[0].mean()\n self.norm_radius.data = (\n self.norm_radius.data * (1 - self.norm_radius_momentum)\n + mean_radius * self.norm_radius_momentum\n )\n\n # normalize\n pts = pts / self.norm_radius\n\n # estimate distance weights\n distance_weight = torch.sigmoid(-self.alpha * distances + self.beta)\n distance_weight_s = distance_weight.sum(2, keepdim=True)\n distance_weight_s = distance_weight_s + (distance_weight_s == 0) + 1e-6\n distance_weight = (\n distance_weight / distance_weight_s * distances.shape[2]\n ).unsqueeze(1)\n\n # feature weighting matrix estimation\n if pts.shape[3] == 1:\n mat = F.relu(self.fc1(pts))\n else:\n mat = F.relu(self.bn1(self.fc1(pts)))\n mp1 = torch.max(mat * distance_weight, dim=3, keepdim=True)[0].expand(\n (-1, -1, -1, mat.shape[3])\n )\n mat = torch.cat([mat, mp1], dim=1)\n if pts.shape[3] == 1:\n mat = F.relu(self.fc2(mat))\n else:\n mat = F.relu(self.bn2(self.fc2(mat)))\n mp2 = torch.max(mat * distance_weight, dim=3, keepdim=True)[0].expand(\n (-1, -1, -1, mat.shape[3])\n )\n mat = torch.cat([mat, mp2], dim=1)\n mat = F.relu(self.fc3(mat)) * distance_weight\n # mat = torch.sigmoid(self.fc3(mat)) * distance_weight\n else:\n pts = self.fixed_normalization(pts)\n\n # feature weighting matrix estimation\n if pts.shape[3] == 1:\n mat = F.relu(self.fc1(pts))\n else:\n mat = F.relu(self.bn1(self.fc1(pts)))\n mp1 = torch.max(mat, dim=3, keepdim=True)[0].expand(\n (-1, -1, -1, mat.shape[3])\n )\n mat = torch.cat([mat, mp1], dim=1)\n if pts.shape[3] == 1:\n mat = F.relu(self.fc2(mat))\n else:\n mat = F.relu(self.bn2(self.fc2(mat)))\n mp2 = torch.max(mat, dim=3, keepdim=True)[0].expand(\n (-1, -1, -1, mat.shape[3])\n )\n mat = torch.cat([mat, mp2], dim=1)\n mat = F.relu(self.fc3(mat))\n\n # compute features\n features = torch.matmul(\n x.transpose(1, 2), mat.permute(0, 2, 3, 1)\n ).transpose(1, 2)\n features = self.cv(features).squeeze(3)\n\n return features\n\n" ]	[ [ "torch.sigmoid", "torch.max", "torch.Tensor", "torch.cat", "torch.nn.Conv2d", "torch.nn.init.ones_", "torch.nn.InstanceNorm2d" ] ]
vyk1/YAFS	[ "514f8362c90923fa28f871fcf179b755a9315c47" ]	[ "src/examples/VRGameFog-IFogSim-WL/testConvergence.py" ]	[ "#!/usr/bin/env python2\n# -- coding: utf-8 --\n\"\"\"\nCreated on Thu Sep 6 16:48:57 2018\n\n@author: isaaclera\n\"\"\"\n\nimport numpy as np\n\nYFAS4 = [11.270442,\n11.270623,\n11.270012,\n11.270021,\n11.270031,\n11.269538,\n11.269547,\n11.268429,\n11.270591,\n11.269940,\n11.268374,\n11.270021,\n11.268418,\n11.268944,\n11.268985,\n11.269444,\n11.270576,\n11.270090,\n11.268944,\n11.269489,\n11.269405,\n11.268916,\n11.269418,\n11.270576,\n11.268837,\n11.269988,\n11.268969,\n11.270012,\n11.269471,\n11.270623,\n11.269921,\n11.269926,\n11.270655,\n11.269552,\n11.269983,\n11.270422,\n11.269480,\n11.268385,\n11.270002,\n11.269427,\n11.270660,\n11.270036,\n11.269861,\n11.270591,\n11.268504,\n11.270493,\n11.269964,\n11.269488,\n11.270031,\n11.270581]\n\nYAFS8 = [11.265525,\n11.266339,\n11.266815,\n11.266855,\n11.266066,\n11.266793,\n11.266837,\n11.266059,\n11.266313,\n11.266814,\n11.266597,\n11.266853,\n11.266819,\n11.266840,\n11.266598,\n11.266553,\n11.266891,\n11.266056,\n11.266781,\n11.266583,\n11.266566,\n11.266300,\n11.266042,\n11.266070,\n11.266315,\n11.266567,\n11.266575,\n11.266032,\n11.266579,\n11.266357,\n11.266556,\n11.266026,\n11.266585,\n11.266874,\n11.266852,\n11.266317,\n11.266556,\n11.266585,\n11.266068,\n11.266295,\n11.266595,\n11.266322,\n11.266562,\n11.266813,\n11.266328,\n11.266572,\n11.266858,\n11.266055,\n11.266320,\n11.266334]\n\nYAFS12 = [11.265424,\n11.265598,\n11.265620,\n11.265262,\n11.265421,\n11.265447,\n11.265605,\n11.265604,\n11.265599,\n11.265603,\n11.265615,\n11.265617,\n11.265598,\n11.265611,\n11.265435,\n11.265603,\n11.265604,\n11.264904,\n11.265612,\n11.265434,\n11.265609,\n11.265102,\n11.265423,\n11.265266,\n11.265425,\n11.265250,\n11.265427,\n11.265452,\n11.265432,\n11.265456,\n11.265073,\n11.265626,\n11.265082,\n11.265417,\n11.265081,\n11.265090,\n11.265265,\n11.265614,\n11.265094,\n11.265259,\n11.265436,\n11.265610,\n11.265619,\n11.265598,\n11.265281,\n11.265595,\n11.265083,\n11.265441,\n11.265621,\n11.265591]\n\nYAFS16 =[11.264981,\n11.264608,\n11.264860,\n11.264854,\n11.264883,\n11.264875,\n11.264857,\n11.264865,\n11.264863,\n11.264857,\n11.264860,\n11.264999,\n11.264733,\n11.264727,\n11.264738,\n11.264731,\n11.264991,\n11.264994,\n11.264860,\n11.264999,\n11.265000,\n11.264991,\n11.264983,\n11.264748,\n11.264866,\n11.264988,\n11.264999,\n11.264995,\n11.265004,\n11.264867,\n11.264997,\n11.264882,\n11.264995,\n11.264859,\n11.264741,\n11.264730,\n11.264740,\n11.264865,\n11.264717,\n11.264725,\n11.264734,\n11.264207,\n11.264864,\n11.264866,\n11.264613,\n11.264729,\n11.264743,\n11.264859,\n11.264850,\n11.264727]\n\niFOG4 = [31.567014877440677,\n31.2096085700963,\n31.572940602513007,\n32.09846731216869,\n31.792375613564243,\n31.424621004232844,\n32.04335456925575,\n31.64746479672535,\n31.864294659944616,\n31.953031858836283,\n31.494672286834362,\n31.39366324536594,\n31.9330291330959,\n31.624966442944583,\n31.351483395614157,\n31.360150842367922,\n31.946874707666186,\n31.46681646446987,\n31.725400313292727,\n31.878630822078588,\n31.450552934872057,\n31.561696751665966,\n31.760980953726737,\n31.61584410211693,\n31.85765037646526,\n31.588118685691732,\n31.538965103047765,\n31.875204878212468,\n32.04039882134873,\n31.974034757361743,\n31.825800952238026,\n31.860045585250894,\n31.74689429856358,\n31.595326959974482,\n31.567728517075153,\n31.67316165064918,\n31.734033481104987,\n31.747852362825974,\n31.697831781669656,\n31.449777335693597,\n31.633845469419953,\n31.261946244207035,\n31.512462484441933,\n31.738540845661536,\n31.829588718812303,\n31.61758201414952,\n31.755117403160344,\n31.684510700310877,\n31.663332103705088,\n31.59112414160327,\n31.736744614282188]\n\niFOG8 = [31.824870005152544,\n31.308233878305664,\n31.63140903918994,\n31.607322598441506,\n31.797154459140017,\n31.60744992813196,\n31.78501672169974,\n31.313537275709574,\n31.556893939936433,\n31.813897687958356,\n31.546548077781956,\n31.54571365545189,\n31.7610100755262,\n31.657092962150408,\n31.811162052815273,\n31.87786253393602,\n31.733055897530978,\n31.66802107358438,\n31.86733314438995,\n31.60201939019151,\n31.856532456020354,\n31.593935385166244,\n31.91018849931251,\n31.741217704968758,\n31.71168869299696,\n31.68676569379744,\n31.654600237926505,\n31.634309962315537,\n31.78376537464453,\n31.523910842992237,\n31.344856954660475,\n31.802250975942954,\n31.49838544019412,\n31.71671805331793,\n31.681395720312402,\n31.873480122111538,\n31.842035466656807,\n31.60424413680737,\n31.677882323684667,\n31.60865151246418,\n31.605794410152583,\n31.7091690924313,\n31.586701523045587,\n31.67643022244788,\n31.65827077853141,\n31.51779854040955]\n\niFOG12 = [31.527656135037645,\n31.566542875429953,\n31.583142226513335,\n31.7183597304816,\n31.617750133241476,\n31.885462498982793,\n31.539747456559475,\n31.657806149276933,\n31.65879173721966,\n31.60788495755312,\n31.75726587500943,\n31.712496136707237,\n31.499593245681424,\n31.508957387495002,\n31.761966259831276,\n31.698547661932345,\n31.801609867084004,\n31.6381053991471,\n31.6363948406526,\n31.67585787825071,\n31.66730693446405,\n31.68694412821118,\n31.804783015645324,\n31.597311537070794,\n31.57325161001325,\n31.587005485736235,\n31.757460511381755,\n31.693234605929035,\n31.674055061553943,\n31.64761152308104,\n31.54117279204224,\n31.54233248362793,\n31.569759110769073,\n31.486255820595197,\n31.609553939297612,\n31.85137358126173,\n32.01635987575208,\n31.65992722412061,\n31.593333594011373,\n31.692828648641054,\n31.71146206016865,\n31.38862252584211,\n31.897913580557333,\n31.830566331867267,\n31.426588863591125,\n31.63415020297928]\n\niFOG16 = [31.44319878979343,\n31.552334454736133,\n31.682084871564953,\n31.761914523261304,\n31.810926207188768,\n31.561097434192455,\n31.779844957414298,\n31.392378353361043,\n31.873843235026225,\n31.744376676391745,\n31.625968801049037,\n31.602215698677004,\n31.813225776124753,\n31.562337244472484,\n31.696847808168243,\n31.903286751887627,\n31.519814582748293,\n31.54366633216892,\n31.58841433840935,\n31.4630381792411,\n31.874078090902373,\n31.690547620132648,\n31.59378772837774,\n31.612639941031595,\n31.568692958222847,\n31.532164860225638,\n31.726651022826655,\n31.802570700370133,\n31.735676103172228,\n31.6413832499989,\n31.59990847806666,\n31.5974415806301,\n31.592421292125856,\n31.700416447580768,\n31.76237040195895,\n31.669176402727306,\n31.741612269184262,\n31.772092793236496,\n31.49199967976739,\n31.88103118845454,\n31.57354311237185,\n31.478132563277104,\n31.847975187719452,\n31.57405712508705,\n31.810763820819652,\n31.55968399736258]\n\nttt = np.array(iFOG16)\nfrom scipy import stats\nprint(stats.describe(ttt))" ]	[ [ "numpy.array", "scipy.stats.describe" ] ]
jm-begon/globally-induced-forest	[ "bf41640a5f0d9db637877dfa077b1d529539dbc6" ]	[ "gif/datasets/setup.py" ]	[ "import os\n\nimport numpy\nfrom numpy.distutils.misc_util import Configuration\n\n\ndef configuration(parent_package=\"\", top_path=None):\n config = Configuration(\"datasets\", parent_package, top_path)\n\n return config\n\nif __name__ == \"__main__\":\n from numpy.distutils.core import setup\n setup(**configuration().todict())\n" ]	[ [ "numpy.distutils.misc_util.Configuration" ] ]
Zhanghaotian1/SDE_conf	[ "90773e807ab8ccdc1963e113a2c72df16b8899c1" ]	[ "SDE_CG_C/utils/evaluation.py" ]	[ "import numpy as np\nfrom tqdm.auto import tqdm\n\nimport torch\nfrom torch_geometric.data import Data\nfrom rdkit import Chem\nfrom rdkit.Chem.rdForceFieldHelpers import MMFFOptimizeMolecule\n\nfrom SDE_CG import utils\n\n\ndef get_rmsd_confusion_matrix(data: Data, useFF=False):\n data.pos_ref = data.pos_ref.view(-1, data.num_nodes, 3)\n data.pos_gen = data.pos_gen.view(-1, data.num_nodes, 3)\n num_gen = data.pos_gen.size(0)\n num_ref = data.pos_ref.size(0)\n\n assert num_gen == data.num_pos_gen.item()\n assert num_ref == data.num_pos_ref.item()\n\n rmsd_confusion_mat = -1 * np.ones([num_ref, num_gen],dtype=np.float)\n \n for i in range(num_gen):\n gen_mol = utils.set_rdmol_positions(data.rdmol, data.pos_gen[i])\n if useFF:\n #print('Applying FF on generated molecules...')\n MMFFOptimizeMolecule(gen_mol)\n for j in range(num_ref):\n ref_mol = utils.set_rdmol_positions(data.rdmol, data.pos_ref[j])\n \n rmsd_confusion_mat[j,i] = utils.GetBestRMSD(gen_mol, ref_mol)\n\n return rmsd_confusion_mat\n \n\ndef evaluate_conf(data: Data, useFF=False, threshold=0.5):\n rmsd_confusion_mat = get_rmsd_confusion_matrix(data, useFF=useFF)\n rmsd_ref_min = rmsd_confusion_mat.min(-1)\n return (rmsd_ref_min<=threshold).mean(), rmsd_ref_min.mean()\n\n\ndef evaluate_distance(data: Data, ignore_H=True):\n data.pos_ref = data.pos_ref.view(-1, data.num_nodes, 3) # (N, num_node, 3)\n data.pos_gen = data.pos_gen.view(-1, data.num_nodes, 3) # (M, num_node, 3)\n num_ref = data.pos_ref.size(0) # N\n num_gen = data.pos_gen.size(0) # M\n assert num_gen == data.num_pos_gen.item()\n assert num_ref == data.num_pos_ref.item()\n smiles = data.smiles\n\n edge_index = data.edge_index\n atom_type = data.atom_type\n\n # compute generated length and ref length \n ref_lengths = (data.pos_ref[:, edge_index[0]] - data.pos_ref[:, edge_index[1]]).norm(dim=-1) # (N, num_edge)\n gen_lengths = (data.pos_gen[:, edge_index[0]] - data.pos_gen[:, edge_index[1]]).norm(dim=-1) # (M, num_edge)\n # print(ref_lengths.size(), gen_lengths.size())\n #print(ref_lengths.size())\n #print(gen_lengths.size())\n\n stats_single = []\n first = 1\n for i, (row, col) in enumerate(tqdm(edge_index.t())):\n if row >= col: \n continue\n if ignore_H and 1 in (atom_type[row].item(), atom_type[col].item()): \n continue\n gen_l = gen_lengths[:, i]\n ref_l = ref_lengths[:, i]\n if first:\n print(gen_l.size(), ref_l.size())\n first = 0\n mmd = compute_mmd(gen_l.view(-1, 1).cuda(), ref_l.view(-1, 1).cuda()).item()\n stats_single.append({\n 'edge_id': i,\n 'elems': '%s - %s' % (utils.get_atom_symbol(atom_type[row].item()), utils.get_atom_symbol(atom_type[col].item())),\n 'nodes': (row.item(), col.item()),\n 'gen_lengths': gen_l.cpu(),\n 'ref_lengths': ref_l.cpu(),\n 'mmd': mmd\n })\n\n first = 1\n stats_pair = []\n for i, (row_i, col_i) in enumerate(tqdm(edge_index.t())):\n if row_i >= col_i: \n continue\n if ignore_H and 1 in (atom_type[row_i].item(), atom_type[col_i].item()): \n continue\n for j, (row_j, col_j) in enumerate(edge_index.t()):\n if (row_i >= row_j) or (row_j >= col_j): \n continue\n if ignore_H and 1 in (atom_type[row_j].item(), atom_type[col_j].item()): \n continue\n\n gen_L = gen_lengths[:, (i,j)] # (N, 2)\n ref_L = ref_lengths[:, (i,j)] # (M, 2)\n if first:\n # print(gen_L.size(), ref_L.size())\n first = 0\n mmd = compute_mmd(gen_L.cuda(), ref_L.cuda()).item()\n\n stats_pair.append({\n 'edge_id': (i, j),\n 'elems': (\n '%s - %s' % (utils.get_atom_symbol(atom_type[row_i].item()), utils.get_atom_symbol(atom_type[col_i].item())), \n '%s - %s' % (utils.get_atom_symbol(atom_type[row_j].item()), utils.get_atom_symbol(atom_type[col_j].item())), \n ),\n 'nodes': (\n (row_i.item(), col_i.item()),\n (row_j.item(), col_j.item()),\n ),\n 'gen_lengths': gen_L.cpu(),\n 'ref_lengths': ref_L.cpu(),\n 'mmd': mmd\n }) \n\n edge_filter = edge_index[0] < edge_index[1]\n if ignore_H:\n for i, (row, col) in enumerate(edge_index.t()): \n if 1 in (atom_type[row].item(), atom_type[col].item()):\n edge_filter[i] = False\n\n gen_L = gen_lengths[:, edge_filter] # (N, Ef)\n ref_L = ref_lengths[:, edge_filter] # (M, Ef)\n # print(gen_L.size(), ref_L.size())\n mmd = compute_mmd(gen_L.cuda(), ref_L.cuda()).item()\n\n stats_all = {\n 'gen_lengths': gen_L.cpu(),\n 'ref_lengths': ref_L.cpu(),\n 'mmd': mmd\n }\n return stats_single, stats_pair, stats_all\n\ndef guassian_kernel(source, target, kernel_mul=2.0, kernel_num=5, fix_sigma=None):\n '''\n Params:\n\t source: n * len(x)\n\t target: m * len(y)\n\tReturn:\n\t\tsum(kernel_val): Sum of various kernel matrices\n '''\n n_samples = int(source.size()[0])+int(target.size()[0])\n total = torch.cat([source, target], dim=0)\n total0 = total.unsqueeze(0).expand(int(total.size(0)), int(total.size(0)), int(total.size(1)))\n total1 = total.unsqueeze(1).expand(int(total.size(0)), int(total.size(0)), int(total.size(1)))\n\n L2_distance = ((total0-total1)2).sum(2)\n\n if fix_sigma:\n bandwidth = fix_sigma\n else:\n bandwidth = torch.sum(L2_distance.data) / (n_samples2-n_samples)\n\n bandwidth /= kernel_mul ** (kernel_num // 2)\n bandwidth_list = [bandwidth * (kernel_mul**i) for i in range(kernel_num)]\n\n kernel_val = [torch.exp(-L2_distance / bandwidth_temp) for bandwidth_temp in bandwidth_list]\n\n return sum(kernel_val)#/len(kernel_val)\n \ndef compute_mmd(source, target, kernel_mul=2.0, kernel_num=5, fix_sigma=None):\n '''\n Params:\n\t source: (N, D)\n\t target: (M, D)\n\tReturn:\n\t\tloss: MMD loss\n '''\n batch_size = int(source.size()[0])\n kernels = guassian_kernel(source, target,\n kernel_mul=kernel_mul, kernel_num=kernel_num, fix_sigma=fix_sigma)\n\n XX = kernels[:batch_size, :batch_size]\n YY = kernels[batch_size:, batch_size:]\n XY = kernels[:batch_size, batch_size:]\n YX = kernels[batch_size:, :batch_size]\n loss = torch.mean(XX) + torch.mean(YY) - torch.mean(XY) - torch.mean(YX)\n\n return loss\n\n\n\"\"\"\nAnother implementation:\n https://github.com/martinepalazzo/kernel_methods/blob/master/kernel_methods.py\n\"\"\"" ]	[ [ "torch.mean", "torch.cat", "torch.sum", "numpy.ones", "torch.exp" ] ]
will-jj/arim	[ "fc15efe171a41355090123fcea10406ee75efe31" ]	[ "arim/plot.py" ]	[ "\"\"\"\nPlotting utilities based on `matplotib <http://matplotlib.org/>`_.\n\nSome default values are configurable via the dictionary ``arim.plot.conf``.\n\n.. py:data:: conf\n\n Dictionary of default values. For some functions, if an argument is not populated,\n its values will be populated from this dictionary. Example::\n\n # save the figure (independently on conf['savefig])\n plot_oyz(data, grid, savefig=True, filename='foo')\n\n # do not save the figure independently on conf['savefig])\n plot_oyz(data, grid, savefig=False, filename='foo')\n\n # save the figure depending only if conf['savefig'] is True\n plot_oyz(data, grid, filename='foo')\n\n.. py:data:: micro_formatter\n.. py:data:: milli_formatter\n.. py:data:: mega_formatter\n\n Format the labels of an axis in a given unit prefix. Usage::\n\n import matplotlib.pyplot as plt\n ax = plt.plot(distance_vector, data)\n ax.xaxis.set_major_formatter(arim.plot.milli_formatter)\n\n\"\"\"\n\nfrom warnings import warn\nimport logging\n\nfrom matplotlib import ticker\nfrom mpl_toolkits import axes_grid1\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport scipy.signal\n\nfrom . import ut\nfrom .exceptions import ArimWarning\nfrom . import geometry as g\nfrom .config import Config\n\n__all__ = [\n \"micro_formatter\",\n \"mega_formatter\",\n \"milli_formatter\",\n \"plot_bscan\",\n \"plot_bscan_pulse_echo\",\n \"plot_oxz\",\n \"plot_oxz_many\",\n \"plot_tfm\",\n \"plot_directivity_finite_width_2d\",\n \"draw_rays_on_click\",\n \"RayPlotter\",\n \"conf\",\n \"common_dynamic_db_scale\",\n]\n\nlogger = logging.getLogger(__name__)\n\nmicro_formatter = ticker.FuncFormatter(lambda x, pos: \"{:.1f}\".format(x * 1e6))\nmicro_formatter.__doc__ = \"Format an axis to micro (µ).\\nExample: ``ax.xaxis.set_major_formatter(micro_formatter)``\"\n\nmilli_formatter = ticker.FuncFormatter(lambda x, pos: \"{:.1f}\".format(x * 1e3))\nmilli_formatter.__doc__ = \"Format an axis to milli (m).\\nExample: ``ax.xaxis.set_major_formatter(milli_formatter)``\"\n\nmega_formatter = ticker.FuncFormatter(lambda x, pos: \"{:.1f}\".format(x * 1e-6))\nmega_formatter.__doc__ = \"Format an axis to mega (M).\\nExample: ``ax.xaxis.set_major_formatter(mega_formatter)``\"\n\nconf = Config(\n [\n (\"savefig\", False), # save the figure?\n (\"plot_oxz.figsize\", None),\n (\"plot_oxz_many.figsize\", None),\n ]\n)\n\n\ndef plot_bscan(\n frame,\n timetraces_idx,\n use_dB=True,\n ax=None,\n title=\"B-scan\",\n clim=None,\n interpolation=\"none\",\n draw_cbar=True,\n cmap=None,\n savefig=None,\n filename=\"bscan\",\n):\n \"\"\"Plot Bscan (timetraces vs time)\n \n Parameters\n ----------\n frame : Frame\n timetraces_idx : slice or tuple or ndarray\n timetraces to use. Any valid numpy array is accepted.\n use_dB : bool, optional\n ax : matplotlib axis, optional\n Where to draw. Default: create a new figure and axis.\n title : str, optional\n Title of the image (default: \"Bscan\")\n clim : tuple, optional\n Color limits of the image.\n interpolation : str, optional\n Image interpolation type (default: \"none\")\n draw_cbar : bool, optional\n cmap : str, optional\n savefig : bool, optional\n Default: use ``conf[\"savefig\"]``\n filename : str, optional\n Default: \"bscan\"\n \n Returns\n -------\n ax : matplotlib axis\n im : matplotlib image\n\n Examples\n --------\n\n >>> arim.plot.plot_bscan(frame, frame.tx == 0)\n\n \"\"\"\n if ax is None:\n fig, ax = plt.subplots()\n else:\n fig = ax.figure\n\n if savefig is None:\n savefig = conf[\"savefig\"]\n\n timetraces = frame.timetraces[timetraces_idx]\n numtimetraces = timetraces.shape[0]\n if use_dB:\n timetraces = ut.decibel(timetraces)\n if clim is None:\n clim = [-40.0, 0.0]\n\n im = ax.imshow(\n timetraces,\n extent=[frame.time.start, frame.time.end, 0, numtimetraces - 1],\n interpolation=interpolation,\n cmap=cmap,\n origin=\"lower\",\n )\n ax.set_xlabel(\"Time (µs)\")\n ax.set_ylabel(\"TX/RX index\")\n ax.xaxis.set_major_formatter(micro_formatter)\n ax.xaxis.set_minor_formatter(micro_formatter)\n\n # Use element index instead of timetrace index (may be different)\n tx = frame.tx[timetraces_idx]\n rx = frame.rx[timetraces_idx]\n\n def _y_formatter(i, pos):\n i = int(i)\n try:\n return f\"({tx[i]}, {rx[i]})\"\n except IndexError:\n return \"\"\n\n y_formatter = ticker.FuncFormatter(_y_formatter)\n ax.yaxis.set_major_formatter(y_formatter)\n ax.yaxis.set_minor_formatter(y_formatter)\n\n if draw_cbar:\n fig.colorbar(im, ax=ax)\n if clim is not None:\n im.set_clim(clim)\n if title is not None:\n ax.set_title(title)\n\n ax.axis(\"tight\")\n if savefig:\n ax.figure.savefig(filename)\n return ax, im\n\n\ndef plot_bscan_pulse_echo(\n frame,\n use_dB=True,\n ax=None,\n title=\"B-scan (pulse-echo)\",\n clim=None,\n interpolation=\"none\",\n draw_cbar=True,\n cmap=None,\n savefig=None,\n filename=\"bscan\",\n):\n \"\"\"\n Plot a B-scan. Use the pulse-echo timetraces.\n\n Parameters\n ----------\n frame\n use_dB\n ax\n title\n clim\n interpolation\n draw_cbar\n cmap\n\n Returns\n -------\n axis, image\n\n See Also\n --------\n :func:`plot_bscan`\n\n \"\"\"\n pulse_echo = frame.tx == frame.rx\n elements = frame.tx[pulse_echo]\n ax, im = plot_bscan(\n frame,\n pulse_echo,\n use_dB=use_dB,\n ax=ax,\n title=title,\n clim=clim,\n interpolation=interpolation,\n draw_cbar=draw_cbar,\n cmap=cmap,\n savefig=False, # save later\n filename=filename,\n )\n ax.set_ylabel(\"Element\")\n # Use element index instead of timetrace index (may be different)\n def _y_formatter(i, pos):\n i = int(i)\n if i >= len(elements):\n return \"\"\n else:\n return str(elements[i])\n\n y_formatter = ticker.FuncFormatter(_y_formatter)\n ax.yaxis.set_major_formatter(y_formatter)\n ax.yaxis.set_minor_formatter(y_formatter)\n\n if savefig:\n ax.figure.savefig(filename)\n\n return ax, im\n\n\ndef plot_psd(\n frame,\n idx=\"all\",\n to_show=\"filtered\",\n welch_params=None,\n ax=None,\n title=\"Power spectrum estimation\",\n show_legend=True,\n savefig=None,\n filename=\"psd\",\n):\n \"\"\"\n Plot the estimated power spectrum of a timetrace using Welch's method.\n\n Parameters\n ----------\n frame : Frame\n idx : int or slice or list\n Index or indices of the timetrace to use. If multiple indices are given,\n the arithmetical mean of all PSDs is plotted. Default: use all\n to_show\n welch_params : dict\n Arguments to pass to ``scipy.signal.welch``.\n ax : matplotlib.axes.Axes or None\n title\n show_legend\n savefig\n filename\n\n Returns\n -------\n ax : matplotlib.axes.Axes\n lines : dict\n\n \"\"\"\n if ax is None:\n fig, ax = plt.subplots()\n else:\n fig = ax.figure\n\n if welch_params is None:\n welch_params = {}\n\n if savefig is None:\n savefig = conf[\"savefig\"]\n\n if isinstance(idx, str) and idx == \"all\":\n idx = slice(None)\n\n fs = 1 / frame.time.step\n\n to_show = to_show.lower()\n if to_show == \"both\":\n show_raw = True\n show_filtered = True\n elif to_show == \"raw\":\n show_raw = True\n show_filtered = False\n elif to_show == \"filtered\":\n show_raw = False\n show_filtered = True\n else:\n raise ValueError(\"Valid values for 'to_show' are: filtered, raw, both\")\n\n lines = {}\n\n if show_raw:\n x = frame.timetraces_raw[idx].real\n freq, pxx = scipy.signal.welch(x, fs, welch_params)\n if pxx.ndim == 2:\n pxx = np.mean(pxx, axis=0)\n line = ax.plot(freq, pxx, label=\"raw\".format(idx=idx))\n lines[\"raw\"] = line\n if show_filtered:\n x = frame.timetraces[idx].real\n freq, pxx = scipy.signal.welch(x, fs, welch_params)\n if pxx.ndim == 2:\n pxx = np.mean(pxx, axis=0)\n line = ax.plot(freq, pxx, label=\"filtered\".format(idx=idx))\n lines[\"filtered\"] = line\n ax.set_xlabel(\"frequency (MHz)\")\n ax.set_ylabel(\"power spectrum estimation\")\n ax.xaxis.set_major_formatter(mega_formatter)\n ax.xaxis.set_minor_formatter(mega_formatter)\n\n if title is not None:\n ax.set_title(title)\n\n if show_legend:\n ax.legend(loc=\"best\")\n\n if savefig:\n fig.savefig(filename)\n return ax, lines\n\n\ndef plot_oxz(\n data,\n grid,\n ax=None,\n title=None,\n clim=None,\n interpolation=\"none\",\n draw_cbar=True,\n cmap=None,\n figsize=None,\n savefig=None,\n patches=None,\n filename=None,\n scale=\"linear\",\n ref_db=None,\n):\n \"\"\"\n Plot data in the plane Oxz.\n\n Parameters\n ----------\n data : ndarray\n Shape: 2D matrix ``(grid.numx, grid.numz)`` or 3D matrix ``(grid.numx, 1, grid.numz)``\n or 1D matrix ``(grid.numx * grid.numz)``\n grid : Grid\n ax : matplotlib.Axis or None\n Axis where to plot.\n title : str or None\n clim : List[Float] or None\n interpolation : str or None\n draw_cbar : boolean\n cmap\n figsize : List[Float] or None\n Default: ``conf['plot_oxz.figsize']``\n savefig : boolean or None\n If True, save the figure. Default: ``conf['savefig']``\n patches : List[matplotlib.patches.Patch] or None\n Patches to draw\n filename : str or None\n If True\n scale : str or None\n 'linear' or 'db'. Default: 'linear'\n ref_db : float or None\n Value for 0 dB. Used only for scale=db.\n\n Returns\n -------\n axis\n image\n\n Examples\n --------\n ::\n\n grid = arim.geometry.Grid(-5e-3, 5e-3, 0, 0, 0, 15e-3, .1e-3)\n k = 2 * np.pi / 10e-3\n data = (np.cos(grid.x * 2 * k) * np.sin(grid.z * k))\n ax, im = aplt.plot_oxz(data, grid)\n\n\n \"\"\"\n if figsize is None:\n figsize = conf[\"plot_oxz.figsize\"]\n else:\n if ax is not None:\n warn(\n \"figsize is ignored because an axis is provided\",\n ArimWarning,\n stacklevel=2,\n )\n if savefig is None:\n savefig = conf[\"savefig\"]\n\n if ax is None:\n fig, ax = plt.subplots(figsize=figsize)\n else:\n fig = ax.figure\n if patches is None:\n patches = []\n\n valid_shapes = [\n (grid.numx, 1, grid.numz),\n (grid.numx, grid.numz),\n (grid.numx * grid.numz,),\n ]\n if data.shape in valid_shapes:\n data = data.reshape((grid.numx, grid.numz))\n else:\n msg = \"invalid data shape (got {}, expected {} or {} or {})\".format(\n data.shape, valid_shapes\n )\n raise ValueError(msg)\n\n data = np.rot90(data)\n\n scale = scale.lower()\n if scale == \"linear\":\n if ref_db is not None:\n warn(\"ref_db is ignored for linear plot\", ArimWarning, stacklevel=2)\n elif scale == \"db\":\n data = ut.decibel(data, ref_db)\n else:\n raise ValueError(\"invalid scale: {}\".format(scale))\n\n image = ax.imshow(\n data,\n interpolation=interpolation,\n origin=\"lower\",\n extent=(grid.xmin, grid.xmax, grid.zmax, grid.zmin),\n cmap=cmap,\n )\n if ax.get_xlabel() == \"\":\n # avoid overwriting labels\n ax.set_xlabel(\"x (mm)\")\n if ax.get_ylabel() == \"\":\n ax.set_ylabel(\"z (mm)\")\n ax.xaxis.set_major_formatter(milli_formatter)\n ax.xaxis.set_minor_formatter(milli_formatter)\n ax.yaxis.set_major_formatter(milli_formatter)\n ax.yaxis.set_minor_formatter(milli_formatter)\n if draw_cbar:\n # necessary magic to make the colorbar the same height as the image\n divider = axes_grid1.make_axes_locatable(ax)\n cax = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n cax.set_aspect(aspect=20, adjustable=\"box\")\n fig.colorbar(image, ax=ax, cax=cax)\n if clim is not None:\n image.set_clim(clim)\n if title is not None:\n ax.set_title(title)\n for p in patches:\n ax.add_patch(p)\n\n # Like axis('equal') but mitigates https://github.com/matplotlib/matplotlib/issues/11416\n # adjustable=box to avoid white space (default in matplotlib 3)\n ax.axis(aspect=1, adjustable=\"box\")\n ax.axis([grid.xmin, grid.xmax, grid.zmax, grid.zmin])\n if savefig:\n if filename is None:\n raise ValueError(\"filename must be provided when savefig is true\")\n fig.savefig(filename)\n return ax, image\n\n\ndef plot_oxz_many(\n data_list,\n grid,\n nrows,\n ncols,\n title_list=None,\n suptitle=None,\n draw_colorbar=True,\n figsize=None,\n savefig=None,\n clim=None,\n filename=None,\n y_title=1.0,\n y_suptitle=1.0,\n axes_pad=0.1,\n plot_oxz_kwargs,\n):\n \"\"\"\n Plot many Oxz plots on the same figure.\n\n Parameters\n ----------\n data_list : List[ndarray]\n Data are plotted from top left to bottom right, row per row.\n grid : Grid\n nrows : int\n ncols : int\n title_list : List[str] or None\n suptitle : str or None\n draw_colorbar : boolean\n Default: True\n figsize : List[Float] or None\n Default: ``conf['plot_oxz_many.figsize']``\n savefig: boolean\n Default: ``conf['savefig']``\n clim :\n Color limit. Common for all plots.\n filename\n y_title : float\n Adjust y location of the titles.\n y_suptitle : float\n Adjust y location of the titles.\n axes_pad : float\n Pad between images in inches\n\n plot_oxz_kwargs\n\n Returns\n -------\n axes_grid : axes_grid1.ImageGrid\n im_list\n\n \"\"\"\n if savefig is None:\n savefig = conf[\"savefig\"]\n if figsize is None:\n figsize = conf[\"plot_oxz_many.figsize\"]\n\n if title_list is None:\n title_list = [None] len(data_list)\n\n # must use a common clim (otherwise the figure does not make sense)\n if clim is None:\n clim = (\n min(np.nanmin(x) for x in data_list),\n max(np.nanmax(x) for x in data_list),\n )\n\n if draw_colorbar:\n cbar_mode = \"single\"\n else:\n cbar_mode = None\n fig = plt.figure(figsize=figsize)\n axes_grid = axes_grid1.ImageGrid(\n fig,\n 111,\n nrows_ncols=(nrows, ncols),\n axes_pad=axes_pad,\n share_all=True,\n cbar_mode=cbar_mode,\n )\n\n images = []\n for data, title, ax in zip(data_list, title_list, axes_grid):\n # the current function handles saving fig, drawing the cbar and displaying the title\n # so we prevent plot_oxz to do it.\n ax, im = plot_oxz(\n data,\n grid,\n ax=ax,\n clim=clim,\n draw_cbar=False,\n savefig=False,\n plot_oxz_kwargs,\n title=None,\n )\n images.append(im)\n if title is not None:\n ax.set_title(title, y=y_title)\n if suptitle is not None:\n fig.suptitle(suptitle, y=y_suptitle, size=\"x-large\")\n if draw_colorbar:\n cax = axes_grid.cbar_axes[0]\n fig.colorbar(im, cax=cax)\n cax.set_aspect(20, adjustable=\"box\")\n if savefig:\n if filename is None:\n raise ValueError(\"filename must be provided when savefig is true\")\n fig.savefig(filename)\n return axes_grid, images\n\n\ndef plot_tfm(tfm, y=0.0, func_res=None, interpolation=\"bilinear\", plot_oxz_kwargs):\n \"\"\"\n Plot a TFM in plane Oxz.\n\n Parameters\n ----------\n tfm : BaseTFM\n y : float\n interpolation : str\n Cf matplotlib.pyplot.imshow\n func_res : function\n Function to apply on tfm.res before plotting it. Example: ``lambda x: np.abs(x)``\n plot_oxz_kwargs : dict\n\n Returns\n -------\n ax\n image\n\n See Also\n --------\n :func:`plot_oxz`\n\n \"\"\"\n grid = tfm.grid\n iy = np.argmin(np.abs(grid.y - y))\n\n if tfm.res is None:\n raise ValueError(\"No result in this TFM object.\")\n if func_res is None:\n func_res = lambda x: x\n\n data = func_res(tfm.res[:, iy, :])\n\n return plot_oxz(data, grid=grid, interpolation=interpolation, plot_oxz_kwargs)\n\n\ndef plot_directivity_finite_width_2d(element_width, wavelength, ax=None, kwargs):\n \"\"\"\n\n Parameters\n ----------\n element_width\n wavelength\n ax : matplotlib.axes._subplots.AxesSubplot\n kwargs\n\n Returns\n -------\n\n \"\"\"\n if ax is None:\n fig, ax = plt.subplots()\n else:\n fig = ax.figure\n\n title = kwargs.get(\n \"title\", \"Directivity of an element (uniform sources along a straight line)\"\n )\n\n ratio = element_width / wavelength\n theta = np.linspace(-np.pi / 2, np.pi / 2, 100)\n directivity = ut.directivity_finite_width_2d(theta, element_width, wavelength)\n\n ax.plot(\n np.rad2deg(theta),\n directivity,\n label=r\"$a/\\lambda = {:.2f}$\".format(ratio),\n *kwargs,\n )\n ax.set_xlabel(r\"Polar angle $\\theta$ (deg)\")\n ax.set_ylabel(\"directivity (1)\")\n ax.set_title(title)\n ax.set_xlim([-90, 90])\n ax.set_ylim([0, 1.2])\n ax.xaxis.set_major_locator(ticker.MultipleLocator(30.0))\n ax.xaxis.set_minor_locator(ticker.MultipleLocator(15.0))\n ax.yaxis.set_minor_locator(ticker.MultipleLocator(0.1))\n ax.legend()\n return ax\n\n\nclass RayPlotter:\n def __init__(\n self, grid, ray, element_index, linestyle=\"m--\", tolerance_distance=1e-3\n ):\n self.grid = grid\n self.ray = ray\n self.element_index = element_index\n self.linestyle = linestyle\n self._lines = []\n self.debug = False\n self.y = 0\n self.tolerance_distance = tolerance_distance\n\n def __call__(self, event):\n logger.debug(\n \"button=%d, x=%d, y=%d, xdata=%f, ydata=%f\"\n % (event.button, event.x, event.y, event.xdata, event.ydata)\n )\n ax = event.canvas.figure.axes[0]\n if event.button == 1:\n self.draw_ray(ax, event.xdata, event.ydata)\n elif event.button == 3:\n self.clear_rays(ax)\n if self.debug:\n print(\"show_ray_on_clic() finish with no error\")\n\n def draw_ray(self, ax, x, z):\n gridpoints = self.grid.to_1d_points()\n wanted_point = (x, self.y, z)\n point_index = gridpoints.closest_point(wanted_point)\n obtained_point = gridpoints[point_index]\n\n distance = g.norm2((obtained_point - wanted_point))\n if distance > self.tolerance_distance:\n logger.warning(\n \"The closest grid point is far from what you want (dist: {:.2f} mm)\".format(\n distance 1000\n )\n )\n\n legs = self.ray.get_coordinates_one(self.element_index, point_index)\n line = ax.plot(legs.x, legs.z, self.linestyle)\n self._lines.extend(line)\n logger.debug(\"Draw a ray\")\n ax.figure.canvas.draw_idle()\n\n def clear_rays(self, ax):\n \"\"\"Clear all rays\"\"\"\n lines_to_clear = [line for line in ax.lines if line in self._lines]\n for line in lines_to_clear:\n ax.lines.remove(line)\n self._lines.remove(line)\n logger.debug(\"Clear {} ray(s) on figure\".format(len(lines_to_clear)))\n ax.figure.canvas.draw_idle()\n\n def connect(self, ax):\n \"\"\"Connect to matplotlib event backend\"\"\"\n ax.figure.canvas.mpl_connect(\"button_press_event\", self)\n\n\ndef draw_rays_on_click(grid, ray, element_index, ax=None, linestyle=\"m--\"):\n \"\"\"\n Dynamic plotting of rays on a plot.\n\n Left-click: draw a ray between the probe element and the mouse point.\n Right-click: clear all rays in the plot.\n\n Parameters\n ----------\n grid : Grid\n ray : Rays\n\n element_index : int\n ax : Axis\n Matplotlib axis on which to plot. If None: current axis.\n linestyle : str\n A valid matplotlib linestyle. Default: 'm--'\n\n Returns\n -------\n ray_plotter : RayPlotter\n\n \"\"\"\n if ax is None:\n ax = plt.gca()\n ray_plotter = RayPlotter(\n grid=grid, ray=ray, element_index=element_index, linestyle=linestyle\n )\n ray_plotter.connect(ax)\n return ray_plotter\n\n\ndef plot_interfaces(\n oriented_points_list,\n ax=None,\n show_probe=True,\n show_last=True,\n show_orientations=False,\n n_arrows=10,\n title=\"Interfaces\",\n savefig=None,\n filename=\"interfaces\",\n markers=None,\n show_legend=True,\n quiver_kwargs=None,\n):\n \"\"\"\n Plot interfaces on the Oxz plane.\n\n Assume the first interface is for the probe and the last is for the grid.\n\n Parameters\n ----------\n oriented_points_list : list[OrientedPoints]\n ax : matplotlib.axis.Axis\n show_probe : boolean\n Default True\n show_last : boolean\n Default: True. Useful for hiding the grid.\n show_orientations : boolean\n Plot arrows for the orientations. Default: False\n n_arrows : int\n Number of arrows per interface to plot.\n title : str or None\n Title to display. None for no title.\n savefig : boolean\n If True, the plot will be saved. Default: ``conf['savefig']``.\n filename : str\n Filename of the plot, used if savefig is True. Default: 'interfaces'\n markers : List[str]\n Matplotlib markers for each interfaces. Default: '.' for probe, ',k' for the grid,\n '.' for the rest.\n show_legend : boolean\n Default True\n quiver_kwargs : dict\n Arguments for displaying the arrows (cf. matplotlib function 'quiver')\n\n Returns\n -------\n ax : matplotlib.axis.Axis\n\n \"\"\"\n if savefig is None:\n savefig = conf[\"savefig\"]\n\n if ax is None:\n fig, ax = plt.subplots()\n else:\n fig = ax.figure\n\n if quiver_kwargs is None:\n quiver_kwargs = dict(width=0.0003)\n\n numinterfaces = len(oriented_points_list)\n\n if markers is None:\n markers = [\".\"] + [\".\"] * (numinterfaces - 2) + [\",k\"]\n\n for i, (interface, marker) in enumerate(zip(oriented_points_list, markers)):\n if i == 0 and not show_probe:\n continue\n if i == numinterfaces - 1 and not show_last:\n continue\n (line,) = ax.plot(\n interface.points.x, interface.points.z, marker, label=interface.points.name\n )\n\n if show_orientations:\n # arrow every k points\n k = len(interface.points) // n_arrows\n if k == 0:\n k = 1\n # import pytest; pytest.set_trace()\n ax.quiver(\n interface.points.x[::k],\n interface.points.z[::k],\n interface.orientations.x[::k, 2],\n interface.orientations.z[::k, 2],\n color=line.get_color(),\n units=\"xy\",\n angles=\"xy\",\n **quiver_kwargs,\n )\n\n # set labels only if there is none in the axis yet\n if ax.get_xlabel() == \"\":\n ax.set_xlabel(\"x (mm)\")\n if ax.get_ylabel() == \"\":\n ax.set_ylabel(\"z (mm)\")\n\n ax.xaxis.set_major_formatter(milli_formatter)\n ax.yaxis.set_major_formatter(milli_formatter)\n ax.xaxis.set_minor_formatter(milli_formatter)\n ax.yaxis.set_minor_formatter(milli_formatter)\n\n if title is not None:\n ax.set_title(title)\n\n ylim = ax.get_ylim()\n if ylim[0] < ylim[1]:\n ax.invert_yaxis()\n\n if show_legend:\n ax.legend(loc=\"best\")\n\n ax.axis(\"equal\")\n\n if savefig:\n fig.savefig(filename)\n return ax\n\n\ndef common_dynamic_db_scale(data_list, area=None, db_range=40.0, ref_db=None):\n \"\"\"\n Scale such as:\n - 0 dB corresponds to the maximum value in the area for all data arrays,\n - the clim for each data array are bound by the maximum value in the area.\n\n Parameters\n ----------\n data_list\n db_range : float\n\n Yields\n ------\n ref_db\n (clim_min, clim_max)\n\n Examples\n --------\n\n >>> area = grid.points_in_rectbox(xmin=10, xmax=20)\n >>> common_db_scale_iter = common_dynamic_db_scale(data_list, area)\n >>> for data in data_list:\n ... ref_db, clim = next(common_db_scale_iter)\n ... plot_oxz(data, grid, scale='db', ref_db=ref_db, clim=clim)\n\n \"\"\"\n data_max_list = []\n\n if area is None:\n area = slice(None)\n\n for data in data_list:\n data_max_list.append(np.nanmax(np.abs(data[area])))\n if ref_db is None:\n ref_db = max(data_max_list)\n\n data_max_db_list = ut.decibel(data_max_list, ref_db)\n\n for data_max_db in data_max_db_list:\n yield ref_db, (data_max_db - db_range, data_max_db)\n" ]	[ [ "numpy.nanmax", "numpy.rot90", "matplotlib.ticker.MultipleLocator", "matplotlib.pyplot.gca", "numpy.abs", "numpy.linspace", "numpy.nanmin", "matplotlib.pyplot.subplots", "numpy.rad2deg", "numpy.mean", "matplotlib.ticker.FuncFormatter", "matplotlib.pyplot.figure" ] ]
tanfei2007/DeepM6A	[ "ac8b5543db292516ce10cf42b7506004140d4d41", "ac8b5543db292516ce10cf42b7506004140d4d41" ]	[ "Motif_Analysis/Code/optimizer.py", "Code/TSNE/t_SNE_testing_data.py" ]	[ "#*******************\n# Fei Tan\n# [email protected]\n# March 28, 2017\n#*****************\n\n\nimport numpy as np\nimport pprint\n\nfrom keras import backend as K\nfrom collections import OrderedDict\n\nclass Optimizer(object):\n\t\n\tdef __init__(self, seq_input, losses, wrt=None):\n\n\t\tself.seq = seq_input\n\t\tself.loss_functions = []\n\t\tself.wrt = self.seq if wrt is None else wrt\n\n\t\toverall_loss = K.variable(0.)\n\n\t\tfor loss, weight in losses:\n\t\t\tif weight != 0:\n\t\t\t\tloss_fn = weight loss.build_loss()\n\t\t\t\toverall_loss += loss_fn\n\t\t\t\t# learning phase: 0 (test), 1(train)\n\t\t\t\tself.loss_functions.append( ( loss.name, K.function( [self.seq, K.learning_phase()], [loss_fn]) ) )\n\n\t\tgrads = K.gradients(overall_loss, self.wrt)[0]\n\t\tgrads = grads / (K.sqrt(K.mean(K.square(grads))) + K.epsilon())\n\n\t\tself.overall_loss_grad_wrt_fn = K.function([self.seq, K.learning_phase()], [overall_loss, grads, self.wrt])\n\t\t\n\t\n\tdef eval_losses(self, seq):\n\n\t\tlosses = OrderedDict()\n\t\tfor name, fn in self.loss_functions:\n\t\t\tlosses[name] = fn([seq, 0])\n\t\treturn losses\n\n\tdef rmsprop(self, grads, cache=None, decay_rate=0.95):\n\t\tif cache is None:\n\t\t\tcache = np.zeros_like(grads)\n\t\tcache = decay_rate * cache + (1 - decay_rate) * (grads ** 2)\n\t\tstep = -grads / np.sqrt(cache + K.epsilon())\n\t\treturn step, cache\n\n\tdef get_seed_seq(self, seed_seq):\n\t\tsample_size, filter_length, nucleotide_size = self.seq._keras_shape\n\t\tprint(filter_length, nucleotide_size)\n\t\tif seed_seq is None:\n\t\t\tseed_seq = np.ones((filter_length, nucleotide_size))/4.\n\n\t\tseed_seq = np.array([seed_seq], dtype=np.float32)\n\n\t\treturn seed_seq\n\n\n\tdef minimize(self, seed_seq=None, max_iter=200, lr = 0.1, verbose=True):\n\t\t\"\"\"Performs gradient descent on the input sequenc with respect to defined losses\"\"\"\n\t\t\n\t\tseed_seq = self.get_seed_seq(seed_seq)\n\t\tcache = None\n\t\tbest_loss = float('inf')\n\t\tbest_seq = None\n\n\t\tgrads = None\n\n\t\t\n\t\tfor i in range(max_iter):\n\t\t\toverall_loss, grads, wrt_value = self.overall_loss_grad_wrt_fn([seed_seq, 0])\n\n\t\t\tif verbose:\n\t\t\t\tlosses = self.eval_losses(seed_seq)\n\t\t\t\tprint('Interation: {}, losses: {}, overall loss: {}'.format(i+1, pprint.pformat(losses), overall_loss))\n\t\n\t\t\t\n\t\t\t#gradient descent update\n\t\t\tif self.wrt is self.seq:\n\t\t\t\tstep, cache = self.rmsprop(grads, cache)\n\t\t\t\t\n\t\t\t\t#to be revised later\n\t\t\t\tseed_seq += lr * step\n\t\t\t\n\t\t\tif overall_loss < best_loss:\n\t\t\t\tbest_loss = overall_loss\n\t\t\t\tbest_seq = seed_seq.copy()\n\n\n\t\treturn best_seq[0], grads, wrt_value\n", "import numpy as np\nimport h5py\nimport pandas as pd\nfrom sklearn.manifold import TSNE\n\n# Read testing data\ntestmat = h5py.File('data/m6A_30.test_1.hdf5', 'r')\nX_test = np.transpose(np.array(testmat['x_train']),axes=(0,2, 1))\ny_test = np.array(testmat['y_train'])\n# Transfer 3-D array to 2-D array\nX_test_array = X_test.reshape((X_test.shape[0], -1), order='F')\n\nfeat_cols = [ 'seq'+str(i) for i in range(X_test_array.shape[1]) ]\n\ndf = pd.DataFrame(X_test_array,columns=feat_cols)\ndf['label'] = y_test\ndf['label'] = df['label'].apply(lambda i: str(i))\n\n# Sample 10000 sequences to plot\nnp.random.seed(1337) # for reproducibility\nn_sne = 10000\nrndperm = np.random.permutation(df.shape[0])\n\n\ntsne = TSNE(n_components=2, verbose=1, perplexity=40, n_iter=300)\ntsne_results = tsne.fit_transform(df.loc[rndperm[:n_sne],feat_cols].values)\n\ndf_tsne = df.loc[rndperm[:n_sne],:].copy()\ndf_tsne['x-tsne'] = tsne_results[:,0]\ndf_tsne['y-tsne'] = tsne_results[:,1]\n\ndf_tsne.to_csv('Raw_test_seq_tsne.csv', index = False)\n" ]	[ [ "numpy.array", "numpy.zeros_like", "numpy.ones" ], [ "numpy.random.seed", "pandas.DataFrame", "sklearn.manifold.TSNE", "numpy.random.permutation", "numpy.array" ] ]
malikasng/Bbox_HGG_with_CTR_and_RRTstarFND	[ "2b1aae6c347f544fefface0c9f26dc4ecde51108" ]	[ "utils/stable_baselines_plotter.py" ]	[ "# from https://github.com/hill-a/stable-baselines/blob/master/stable_baselines/results_plotter.py\nimport numpy as np\nimport matplotlib\nimport matplotlib.pyplot as plt\nimport pandas as pd\n\n# matplotlib.use('TkAgg') # Can change to 'Agg' for non-interactive mode\nplt.rcParams['svg.fonttype'] = 'none'\n\nX_TIMESTEPS = 'timesteps'\nX_EPISODES = 'episodes'\nX_WALLTIME = 'walltime_hrs'\nPOSSIBLE_X_AXES = [X_TIMESTEPS, X_EPISODES, X_WALLTIME]\nCOLORS = ['blue', 'green', 'red', 'cyan', 'magenta', 'yellow', 'black', 'purple', 'pink',\n 'brown', 'orange', 'teal', 'coral', 'lightblue', 'lime', 'lavender', 'turquoise',\n 'darkgreen', 'tan', 'salmon', 'gold', 'lightpurple', 'darkred', 'darkblue']\n\n\ndef rolling_window(array, window):\n \"\"\"\n apply a rolling window to a np.ndarray\n :param array: (np.ndarray) the input Array\n :param window: (int) length of the rolling window\n :return: (np.ndarray) rolling window on the input array\n \"\"\"\n shape = array.shape[:-1] + (array.shape[-1] - window + 1, window)\n strides = array.strides + (array.strides[-1],)\n return np.lib.stride_tricks.as_strided(array, shape=shape, strides=strides)\n\n\ndef window_func(var_1, var_2, window, func):\n \"\"\"\n apply a function to the rolling window of 2 arrays\n :param var_1: (np.ndarray) variable 1\n :param var_2: (np.ndarray) variable 2\n :param window: (int) length of the rolling window\n :param func: (numpy function) function to apply on the rolling window on variable 2 (such as np.mean)\n :return: (np.ndarray, np.ndarray) the rolling output with applied function\n \"\"\"\n var_2_window = rolling_window(var_2, window)\n function_on_var2 = func(var_2_window, axis=-1)\n return var_1[window - 1:], function_on_var2\n\n\n '''def ts2xy(timesteps, xaxis):\n \"\"\"\n Decompose a timesteps variable to x ans ys\n :param timesteps: (Pandas DataFrame) the input data\n :param xaxis: (str) the axis for the x and y output\n (can be X_TIMESTEPS='timesteps', X_EPISODES='episodes' or X_WALLTIME='walltime_hrs')\n :return: (np.ndarray, np.ndarray) the x and y output\n \"\"\"\n if xaxis == X_TIMESTEPS:\n x_var = np.cumsum(timesteps.l.values)\n y_var = timesteps.r.values\n elif xaxis == X_EPISODES:\n x_var = np.arange(len(timesteps))\n y_var = timesteps.r.values\n elif xaxis == X_WALLTIME:\n x_var = timesteps.t.values / 3600.\n y_var = timesteps.r.values\n else:\n raise NotImplementedError\n return x_var, y_var'''\n\n\ndef plot_curves(xy_list, xlabel, ylabel, window=1, labels=None,title=None, filename=None):\n \"\"\"\n plot the curves\n :param xy_list: ([(np.ndarray, np.ndarray)]) the x and y coordinates to plot\n :param x_label: (str) the axis for the x and y output\n (can be X_TIMESTEPS='timesteps', X_EPISODES='episodes' or X_WALLTIME='walltime_hrs')\n :param title: (str) the title of the plot\n \"\"\"\n plt.figure(figsize=(16, 8))\n maxx = max(xy[0][-1] for xy in xy_list)\n minx = 0\n for (i, (x, y)) in enumerate(xy_list):\n color = COLORS[i]\n #plt.scatter(x, y, s=2)\n # Do not plot the smoothed curve at all if the timeseries is shorter than window size.\n if x.shape[0] >= window:\n # Compute and plot rolling mean with window of size EPISODE_WINDOW\n x, y_mean = window_func(x, y, window, np.mean)\n if labels is None:\n plt.plot(x, y_mean, color=color)\n else:\n plt.plot(x, y_mean, color=color, label =labels[i])\n plt.xlim(minx, maxx)\n if title is not None:\n plt.title(title)\n plt.legend(loc=\"upper left\")\n plt.xlabel(xlabel)\n plt.ylabel(ylabel)\n plt.tight_layout()\n if filename is not None:\n plt.savefig(filename)\n\n\n'''def plot_results(dirs, num_timesteps, xaxis, task_name):\n \"\"\"\n plot the results\n :param dirs: ([str]) the save location of the results to plot\n :param num_timesteps: (int or None) only plot the points below this value\n :param xaxis: (str) the axis for the x and y output\n (can be X_TIMESTEPS='timesteps', X_EPISODES='episodes' or X_WALLTIME='walltime_hrs')\n :param task_name: (str) the title of the task to plot\n \"\"\"\n\n tslist = []\n for folder in dirs:\n timesteps = load_results(folder)\n if num_timesteps is not None:\n timesteps = timesteps[timesteps.l.cumsum() <= num_timesteps]\n tslist.append(timesteps)\n xy_list = [ts2xy(timesteps_item, xaxis) for timesteps_item in tslist]\n plot_curves(xy_list, xaxis, task_name)'''\n\n'''def main():\n \"\"\"\n Example usage in jupyter-notebook\n .. code-block:: python\n from stable_baselines import results_plotter\n %matplotlib inline\n results_plotter.plot_results([\"./log\"], 10e6, results_plotter.X_TIMESTEPS, \"Breakout\")\n Here ./log is a directory containing the monitor.csv files\n \"\"\"\n import argparse\n import os\n parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n parser.add_argument('--dirs', help='List of log directories', nargs='*', default=['./log'])\n parser.add_argument('--num_timesteps', type=int, default=int(10e6))\n parser.add_argument('--xaxis', help='Varible on X-axis', default=X_TIMESTEPS)\n parser.add_argument('--task_name', help='Title of plot', default='Breakout')\n args = parser.parse_args()\n args.dirs = [os.path.abspath(folder) for folder in args.dirs]\n plot_results(args.dirs, args.num_timesteps, args.xaxis, args.task_name)\n plt.show()'''\n\ndef tdm_training_plot():\n df = pd.read_csv('../logsdir/csv_logs/2020_07_02_12_18_26tdm_training_log.csv')\n indexes = df.columns.values\n '''df.dropna(subset=[i for i in indexes if i != 'epoch'],\n inplace=True, how='all')#this is just because logger creates empty row after before each epoch'''\n\n epoch_time = df[['epoch', 'time']].groupby(by=['epoch'])\n epoch_time = epoch_time.last()\n y = epoch_time[['time']].values[:, 0]\n x = np.arange(0, len(y))\n plot_curves([(x, y)], 'epoch', 'time needed', title='(mixed)',\n filename='../logsdir/csv_logs/time.png')\n\n epAndEpoch_losses = df[\n ['epoch', 'episode', 'actor_tr_loss', 'critic_tr_loss', 'actor_eval_loss', 'critic_eval_loss']\n ].dropna(subset=['episode']).fillna(0.)\n x = np.arange(0, len(epAndEpoch_losses))\n losses_labels = ['actor_tr_loss', 'critic_tr_loss', 'actor_eval_loss', 'critic_eval_loss']\n xs_ys = [(x, epAndEpoch_losses[[k]].values[:, 0])\n for k in losses_labels]\n plot_curves(xs_ys, 'episode (each 100 timesteps)', 'loss', window=20, title='accumulated loss (mixed)',\n labels=losses_labels, filename='../logsdir/csv_logs/log_losses.png')\n\n epAndEpoch_reward = df[['epoch', 'episode', 'episode_reward']].dropna(subset=['episode'])\n epAndEpoch_distance = df[['epoch', 'episode', 'distance_to_goal']].dropna(subset=['episode'])\n\n y = epAndEpoch_distance[['distance_to_goal']].values[:, 0]\n x = np.arange(0, len(y))\n plot_curves([(x, y)], 'episode', 'distance to goal (euclidean distance)', title='distance after episode (mixed)',\n window=20, filename='../logsdir/csv_logs/distance.png')\n\ndef plot_distances(df, columns_names, labels, name):\n x = np.arange(0, len(df))\n xs_ys = [(x, df[[k]].values[:, 0]) for k in columns_names]\n plot_curves(xs_ys, 'step', 'distance ', title='distance '+name,\n labels=labels, filename='../logsdir/csv_logs/distance_evaluation_'+name+'.png')\n\n\n\ndef plot_against(path_to_folder,csv_filename_prefix, route1_name, route2_name, epoch):\n df1 = pd.read_csv(path_to_folder + csv_filename_prefix+route1_name + '.csv')\n df2 = pd.read_csv(path_to_folder +csv_filename_prefix+ route2_name + '.csv')\n def plot_ag(columns_names, labels):\n x = np.arange(0, len(df1))\n xs_ys = [(x, df1[[k]].values[:, 0]) for k in columns_names]\n xs_ys2 = [(x, df2[[k]].values[:, 0]) for k in columns_names]\n l1 = [l + '_'+route1_name for l in labels]\n l2 = [l + '_'+route2_name for l in labels]\n plot_curves(xs_ys + xs_ys2, 'step', 'distance ', title='distance ' +route1_name+'_against_'+route2_name,\n labels=l1 + l2,\n filename=path_to_folder + route1_name+'_against_'+\n route2_name+'_'+'_'.join(labels) +'_epoch{}'.format(epoch)+'.png')\n columns_names_goal = ['from_achieved_goal_to_desired_goal_l2_dist']\n labels_goal = ['l2_distance']\n plot_ag(columns_names_goal, labels_goal)\n\n columns_names_goal = ['from_state_latent_to_goal_latent_estimator1']\n labels_goal = ['estimator1']\n plot_ag(columns_names_goal, labels_goal)\n\n columns_names_goal = ['from_state_latent_to_goal_latent_estimator2']\n labels_goal = ['estimator2']\n plot_ag(columns_names_goal, labels_goal)\n\n\ndef plot_distance_estimators(df, name_prefix):\n #to goal\n plot_distances(df, ['from_achieved_goal_to_desired_goal_l2_dist', 'from_state_latent_to_goal_latent_estimator1',\n 'from_state_latent_to_goal_latent_estimator2'],\n ['l2_distance', 'estimator1', 'estimator2'],\n name_prefix + '_distance_to_goal')\n plot_distances(df, ['from_achieved_goal_to_desired_goal_l2_dist', 'from_state_latent_to_goal_latent_estimator1'],\n ['l2_distance', 'estimator1'],\n name_prefix + '_distance_to_goal_estimator_1')\n plot_distances(df, ['from_achieved_goal_to_desired_goal_l2_dist', 'from_state_latent_to_goal_latent_estimator2'],\n ['l2_distance', 'estimator2'],\n name_prefix + '_distance_to_goal_estimator_2')\n # to last state\n plot_distances(df, ['from_achieved_goal_to_achieved_goal_l2_dist', 'from_state_latent_to_state_latent_estimator1',\n 'from_state_latent_to_state_latent_estimator2', 'to_last_steps'],\n ['l2_distance', 'estimator1', 'estimator2', 'steps_distance'],\n name_prefix + '_distance_to_last_state')\n plot_distances(df, ['from_achieved_goal_to_achieved_goal_l2_dist', 'from_state_latent_to_state_latent_estimator1',\n 'to_last_steps'],\n ['l2_distance', 'estimator1', 'steps_distance'],\n name_prefix + '_distance_to_last_state_estimator_1')\n plot_distances(df, ['from_achieved_goal_to_achieved_goal_l2_dist', 'from_state_latent_to_state_latent_estimator2',\n 'to_last_steps'],\n ['l2_distance', 'estimator2', 'steps_distance'],\n name_prefix + '_distance_to_last_state_estimator_2')\n #to last trajectory\n plot_distances(df, ['achieved_goal_l2_dist_traj', 'state_latent_estimator1_traj',\n 'state_latent_estimator2_traj', 'to_last_steps'],\n ['l2_distance', 'estimator1', 'estimator2', 'steps_distance'],\n name_prefix + '_along_trajectory_cumulated')\n plot_distances(df, ['achieved_goal_l2_dist_traj', 'state_latent_estimator1_traj',\n 'to_last_steps'],\n ['l2_distance', 'estimator1', 'steps_distance'],\n name_prefix + '_along_trajectory_cumulated_estimator_1')\n plot_distances(df, ['achieved_goal_l2_dist_traj', 'state_latent_estimator2_traj',\n 'to_last_steps'],\n ['l2_distance', 'estimator2', 'steps_distance'],\n name_prefix + '_along_trajectory_cumulated_estimator_2')\n # to next\n plot_distances(df, ['achieved_goal_to_next_l2_dist', 'state_latent_to_next_estimator1',\n 'state_latent_to_next_estimator2'],\n ['l2_distance', 'estimator1', 'estimator2'],\n name_prefix + '_to_next')\n plot_distances(df, ['achieved_goal_to_next_l2_dist', 'state_latent_to_next_estimator2'],\n ['l2_distance', 'estimator1'],\n name_prefix + '_to_next_estimator_1')\n plot_distances(df, ['achieved_goal_to_next_l2_dist', 'state_latent_to_next_estimator1'],\n ['l2_distance', 'estimator2'],\n name_prefix + '_to_next_estimator_2')\n\ndef plot_distance_estimators_from_training(df, name_prefix):\n #to goal\n plot_distances(df, ['to_goal_l2', 'to_goal_est','to_goal_2est'],\n ['l2_distance', 'estimator1', 'estimator2'],\n name_prefix + '_distance_to_goal')\n plot_distances(df, ['to_goal_l2', 'to_goal_est'],\n ['l2_distance', 'estimator1'],\n name_prefix + '_distance_to_goal_estimator_1')\n plot_distances(df, ['to_goal_l2','to_goal_2est'],\n ['l2_distance', 'estimator2'],\n name_prefix + '_distance_to_goal_estimator_2')\n # to last state\n\n plot_distances(df, ['to_last_l2', 'to_last_est','to_last_2est', 'to_last_steps'],\n ['l2_distance', 'estimator1', 'estimator2', 'steps_distance'],\n name_prefix + '_distance_to_last_state')\n plot_distances(df, ['to_last_l2', 'to_last_est', 'to_last_steps'],\n ['l2_distance', 'estimator1', 'steps_distance'],\n name_prefix + '_distance_to_last_state_estimator_1')\n plot_distances(df, ['to_last_l2','to_last_2est', 'to_last_steps'],\n ['l2_distance', 'estimator2', 'steps_distance'],\n name_prefix + '_distance_to_last_state_estimator_2')\n #to last trajectory\n plot_distances(df, ['to_last_l2_traj', 'to_last_est_traj','to_last_2est_traj', 'to_last_steps'],\n ['l2_distance', 'estimator1', 'estimator2', 'steps_distance'],\n name_prefix + '_along_trajectory_cumulated')\n plot_distances(df, ['to_last_l2_traj', 'to_last_est_traj', 'to_last_steps'],\n ['l2_distance', 'estimator1', 'steps_distance'],\n name_prefix + '_along_trajectory_cumulated_estimator_1')\n plot_distances(df, ['to_last_l2_traj','to_last_2est_traj', 'to_last_steps'],\n ['l2_distance', 'estimator2', 'steps_distance'],\n name_prefix + '_along_trajectory_cumulated_estimator_2')\n\n # to next\n plot_distances(df, ['to_next_l2','to_next_est','to_next_2est'],\n ['l2_distance', 'estimator1', 'estimator2'],\n name_prefix + '_to_next')\n plot_distances(df, ['to_next_l2','to_next_est'],\n ['l2_distance', 'estimator1'],\n name_prefix + '_to_next_estimator_1')\n plot_distances(df, ['to_next_l2','to_next_2est'],\n ['l2_distance', 'estimator2'],\n name_prefix + '_to_next_estimator_2')\n\ndef plot_distance_group(df, name_prefix):\n def p_points(columns_names, labels, name):\n x = np.arange(0, len(df))\n xs_ys = [(x, df[[k]].values[:, 0]) for k in columns_names]\n plot_curves(xs_ys, 'pair', 'distance', title='distance ' + name,\n labels=labels, filename='../logsdir/csv_logs/distance_evaluation_' + name + '.png')\n p_points(['l2_dist'],['l2_distance'],name_prefix + 'l2_distance')\n p_points(['estimator1'], ['estimator1'],name_prefix + 'estimator1')\n p_points(['estimator2'],['estimator2'],name_prefix + 'estimator2')\n\n\n\nif __name__ == \"__main__\":\n epoch = 390\n '''\n df = pd.read_csv('../logsdir/csv_logs/dist_no_obstacle_epoch_120_it_0.csv')\n plot_distance_estimators_from_training(df,'from_training_epoch_120_it_0')\n '''\n l = ['random','route_1','route_2','route_3_1','route_3_2','route_3_3','route_4_1','route_4_2']\n for r in l:\n df = pd.read_csv('../logsdir/csv_logs/distance_evaluation_'+r+'.csv')\n plot_distance_estimators(df, r+'_epoch_{}_'.format(epoch))\n\n plot_against('../logsdir/csv_logs/','distance_evaluation_','route_3_1','route_3_2', epoch)\n plot_against('../logsdir/csv_logs/', 'distance_evaluation_', 'route_4_1', 'route_4_2', epoch)\n\n for gr in ['a','b','c','d','e','f', 'g', 'h', 'i']:\n df = pd.read_csv('../logsdir/csv_logs/group_'+gr+'.csv')\n plot_distance_group(df, 'group_'+gr+'_epoch_{}_'.format(epoch))\n\n\n\n" ]	[ [ "matplotlib.pyplot.legend", "matplotlib.pyplot.tight_layout", "pandas.read_csv", "matplotlib.pyplot.title", "matplotlib.pyplot.savefig", "numpy.lib.stride_tricks.as_strided", "matplotlib.pyplot.plot", "matplotlib.pyplot.xlim", "matplotlib.pyplot.ylabel", "matplotlib.pyplot.xlabel", "matplotlib.pyplot.figure" ] ]
Preston5789/Stock_Regression_Algorithm	[ "f65dd0c710be777628a0c03ce0fa851880cf0d81" ]	[ "stock_plots.py" ]	[ "\r\nimport matplotlib.pyplot as plt\r\nimport numpy\r\nimport time\r\nfrom matplotlib.widgets import Button\r\n\r\nfrom stock_trade import Jesus\r\nfrom stock_connect import Connection\r\nfrom stock_reg import Errors\r\n\r\nerr = Errors()\r\n\r\ngraphswitcheroo = 0\r\n\r\n\r\ncon = Connection()\r\njes = Jesus()\r\ncon.socket()\r\n\r\nplt.ion()\r\nfig, axs = plt.subplots(4, 1,figsize=(8,10), constrained_layout=True)\r\nx1, y1 = [],[]\r\nx2, y2 = [], []\r\nx3, y3 = [], []\r\nx4, y4 = [], []\r\nbuyx, buyy = [], []\r\nsellx, selly = [], []\r\n\r\ns=2\r\n\r\nlivedata = axs[0].scatter(x1,y1,s=s, c = 'blue')\r\nselldata = axs[0].scatter(sellx, selly, s = 15, c = 'r')\r\nbuydata = axs[0].scatter(buyx, buyy, s = 15, c = 'g')\r\nlnn, = axs[0].plot([],[], 'green', linewidth = 1.0)\r\nln, = axs[0].plot([],[],'red', linewidth = 1.0)\r\n\r\naxs[0].set_title('Live Data')\r\naxs[1].set_title('Linear Regression Analysis')\r\naxs[1].set_ylabel('Slope Value')\r\naxs[0].set_ylabel('Price Over Time')\r\naxs[0].set_xlabel('time (s)')\r\naxs[1].set_xlabel('time (s)')\r\n\r\n\r\nln1, = axs[1].plot([],[], 'r', linewidth = 0.2,)\r\nln2, = axs[1].plot([],[], 'r', linewidth=0.2)\r\nln11, = axs[1].plot([],[], 'g', linewidth=0.4)\r\nln22, = axs[1].plot([],[], 'g', linewidth=0.4)\r\nslopedata = axs[1].scatter(x3,y3, s=s, c = 'black')\r\nslopedata2 = axs[1].scatter(x4,y4, s=s, c = 'blue')\r\nmaxtime = time.time()1000.0 + 20000\r\nbegintime = time.time()1000.0\r\naxs[0].set_xlim(begintime,maxtime)\r\naxs[1].set_xlim(begintime,maxtime)\r\naxs[0].grid()\r\naxs[1].grid()\r\nplt.draw()\r\n\r\n\r\naxs[2].set_title('Regression Trader: Control Panel')\r\naxs[3].set_title('Historical Data')\r\naxs[2].set_ylabel('Price')\r\naxs[2].set_xlabel('Server Time')\r\nticker_text = fig.text(0.5, 0.43, '' , multialignment=\"left\")\r\ntime_text = fig.text(0.5, 0.40, '' , multialignment=\"left\")\r\nyield_text = fig.text(0.5, 0.37, '', multialignment=\"left\")\r\nlossyield_text = fig.text(0.5, 0.34, '', multialignment=\"left\")\r\ntotalsell_text = fig.text(0.5, 0.31, '', multialignment=\"left\")\r\n\r\n\r\ndef _closeshop(event,tickerlist):\r\n jes.closeshop(tickerlist)\r\n\r\ndef on_click(event):\r\n print('doubleclick')\r\n\r\n#definition to cycle through graphs\r\ndef _yes(event):\r\n global graphswitcheroo\r\n graphswitcheroo += 1\r\n if(graphswitcheroo>=14):\r\n graphswitcheroo = 0\r\n\r\n\r\n\r\n#Renders the graph for all of the trading data\r\ndef _rendergraph(event):\r\n print('Generating Graph')\r\n axs[3].clear()\r\n axs[2].set_title('Regression Trader: Controll Panel')\r\n axs[3].set_title('Historical Data')\r\n axs[3].set_ylabel('Price')\r\n axs[3].set_xlabel('Server Time')\r\n axs[3].grid()\r\n x5 = [float(i) for i in con.trackertime_list[graphswitcheroo]]\r\n y5 = [float(i) for i in con.tracker_list[graphswitcheroo]]\r\n axs[3].plot(x5,y5)\r\n axs[3].scatter(sellx, selly,c='red', linewidths=2.0,edgecolors='black',s=60)\r\n axs[3].scatter(buyx,buyy,c='green',linewidths=2.0,edgecolors='black',s=60)\r\n\r\n#Everything to get the buttons together\r\nplt.connect('button_press_event', on_click)\r\nnexcut = plt.axes([0.15, 0.40, .17, .05], facecolor='k')\r\ngraphcut = plt.axes([0.15, 0.32, .3,.06], facecolor = 'k')\r\nwrapcut = plt.axes([0.78, 0.38, .17,.05], facecolor = 'k')\r\nbnexcut = Button(nexcut, 'Next Stock', color='red', hovercolor='white')\r\nbgraphcut = Button(graphcut, 'Generate Graph', color='blue', hovercolor='white')\r\nbwrapcut = Button(wrapcut, 'Wrap It Up', color='yellow',hovercolor='white')\r\nbgraphcut.on_clicked(_rendergraph)\r\nbnexcut.on_clicked(_yes)\r\nbwrapcut.on_clicked(_closeshop)\r\n\r\n\r\n\r\nwhile(True):\r\n\r\n #print(con.tracker_list)\r\n x1 = [float(i) for i in con.trackertime_list[graphswitcheroo][-1000:]]\r\n y1 = [float(i) for i in con.tracker_list[graphswitcheroo][-1000:]]\r\n x2 =[float(i) for i in con.temptime_list[graphswitcheroo]]\r\n y2 =[float(i) for i in con.temp_list[graphswitcheroo]]\r\n buyx = [float(i) for i in jes.buytime_list[graphswitcheroo]]\r\n buyy = [float(i) for i in jes.buy_list[graphswitcheroo]]\r\n sellx =[float(i) for i in jes.selltime_list[graphswitcheroo]]\r\n selly =[float(i) for i in jes.sell_list[graphswitcheroo]]\r\n\r\n\r\n ##Make sure the graphs are all tidy like\r\n if((len(y1)>0)):\r\n axs[0].set_ylim(0.98float(min(y1)) ,1.02float(max(y1)))\r\n time_text.set_text('Current Price: ' + con.temp_list[graphswitcheroo][0].rstrip('0'))\r\n ticker_text.set_text(con.tickerlist[graphswitcheroo])\r\n yield_text.set_text('Permanent Yield: ' + str(jes.tdyyield))\r\n lossyield_text.set_text('Unsold Yield: ' + str(sum(jes.lssyield)))\r\n totalsell_text.set_text('Amount of Trades Holding Assets: ' + str(sum(jes.totalsell)))\r\n axs[0].set_xlim(float(x1[0]), float(x1[-1]))\r\n axs[1].set_xlim(float(x1[0]), float(x1[-1]))\r\n\r\n if(len(buyx) == len(buyy)):\r\n buydata.set_offsets(numpy.c_[buyx, buyy])\r\n if(len(sellx)==len(selly)):\r\n selldata.set_offsets(numpy.c_[sellx, selly])\r\n if(numpy.shape(numpy.array(x1))==numpy.shape(numpy.array(y1))):\r\n livedata.set_offsets(numpy.c_[x1, y1])\r\n\r\n toparray = [float(i) for i in con.toperror_list[graphswitcheroo]]\r\n print(toparray)\r\n bottomarray = [float(i) for i in con.bottomerror_list[graphswitcheroo]]\r\n toparray2 = [float(i) for i in con.toperror2_list[graphswitcheroo]]\r\n bottomarray2 = [float(i) for i in con.bottomerror2_list[graphswitcheroo]]\r\n\r\n\r\n if(len(con.tracker_list[graphswitcheroo])>=35):\r\n\r\n\r\n x3 =[float(i) for i in con.slopetime_list[graphswitcheroo]]\r\n y3 =[float(i) for i in con.slope_list[graphswitcheroo]]\r\n ln1.set_data(x3, toparray)\r\n ln2.set_data(x3, bottomarray)\r\n\r\n print(\"The dimensin of x2 is: {}\".format(len(x2)))\r\n print(\"The dimensin of of line1 is: {}\".format(len(con.line1_list[graphswitcheroo])))\r\n print(con.line1_list[graphswitcheroo])\r\n ln.set_data(x2,con.line1_list[graphswitcheroo])\r\n slopedata.set_offsets(numpy.c_[x3,y3])\r\n\r\n axs[1].set_xlim(x3[0], x3[-1])\r\n axs[1].set_ylim(min(bottomarray),max(toparray))\r\n\r\n if(len(con.tracker_list[graphswitcheroo])>=95):\r\n x4 =[float(i) for i in con.slopetime2_list[graphswitcheroo]]\r\n y4 =[float(i) for i in con.slope2_list[graphswitcheroo]]\r\n y60 = [float(i) for i in con.line2_list[graphswitcheroo]]\r\n x60 = [float(i) for i in con.temptime2_list[graphswitcheroo][0:64]]\r\n ln11.set_data(x4, toparray2)\r\n ln22.set_data(x4, bottomarray2)\r\n lnn.set_data(x60 ,y60)\r\n slopedata2.set_offsets(numpy.c_[x4,y4])\r\n\r\n for i in range(len(con.tickerlist)):\r\n if len(con.tracker_list[i])>100:\r\n jes.defender[i] = True;\r\n\r\n Jesus().decide(con.startbalnace, con.toperror_list, con.bottomerror_list, con.toperror2_list, con.bottomerror2_list, con.temp_list, con.temptime_list, con.tickerlist, con.tracker_list)\r\n\r\n plt.pause(0.01)\r\n\r\n\r\n" ]	[ [ "matplotlib.pyplot.connect", "matplotlib.widgets.Button", "matplotlib.pyplot.subplots", "matplotlib.pyplot.draw", "matplotlib.pyplot.axes", "numpy.array", "matplotlib.pyplot.ion", "matplotlib.pyplot.pause" ] ]
rayjyh/PyTorch_CIFAR10_rram_compenstion	[ "61a53c85a74abc965a5bea3e4b102e9a7ad8f03a" ]	[ "modify_weights.py" ]	[ "import numpy as np\nimport matplotlib.pyplot as plt\nimport torch\n\n'''\ncompensation = {\n \"no_comp\":\n \"simple\":\n \"dynamic\":\n \"bias\":\n \"double_sim\":\n}\n'''\n\nquantized = True\nvisualize = False\nsymmetric = True\n\n\ndef asym_quant_param(w, k):\n num_intervals = 2 k - 1\n scale = (torch.max(w) - torch.min(w)) / num_intervals\n zero = int(-torch.min(w) / scale)\n return num_intervals, scale, zero\n\n\ndef sym_quant_param(w, k):\n num_intervals = 2 k - 1\n scale = max(torch.max(w), -torch.min(w)) / num_intervals\n return num_intervals, scale\n\n\ndef asym_quant(w, num_intervals, scale, zero):\n w_q = torch.round(w / scale) + zero\n w_q = torch.clamp(w_q, 0, num_intervals)\n return w_q\n\n\ndef sym_quant(w, num_intervals, scale):\n w_q = torch.round(w / scale)\n w_q = torch.clamp(w_q, -num_intervals, num_intervals - 1)\n return w_q\n\n\ndef asym_de_quant(w_q, scale, zero):\n w_dq = (w_q - zero) * scale\n return w_dq\n\n\ndef sym_de_quant(w_q, scale):\n w_dq = w_q * scale\n return w_dq\n\n\nclass Compensation:\n def __init__(self,\n absolute_variation=0,\n normal_dist=0,\n var=5,\n var_percentage=7.2,\n scale=10,\n sd=5,\n sd_percentage=0,\n bias=5,\n k_bits=4):\n self.absolute_variation = absolute_variation\n self.normal_dist = normal_dist\n # self.var = var\n self.var_percentage = var_percentage\n self.scale = scale\n self.sd = sd\n self.sd_percentage = sd_percentage\n self.k_bits = k_bits\n self.max = 2 ** self.k_bits - 1\n self.sd = self.sd_percentage * self.max\n self.var = var # * self.max\n self.bias = bias * self.max\n\n def no_comp(self, w):\n if self.absolute_variation:\n pos = torch.abs(w)\n maximum = torch.mean(pos)\n std = self.var * maximum.item()\n real = torch.normal(w, std)\n else:\n if self.normal_dist:\n real = torch.normal(w, self.var_percentage * abs(w))\n else:\n real = w * torch.exp(torch.normal(0, self.var_percentage, size=w.shape, device=w.device))\n # real = torch.clamp(real, 0, self.max)\n return real\n\n def simple(self, w):\n if self.absolute_variation:\n real = torch.normal(w, self.var)\n else:\n real = torch.normal(w, self.var_percentage * abs(w))\n # real = torch.clamp(real, 0, self.max)\n gtz = w > torch.zeros_like(w)\n # stz = w < torch.zeros_like(w)\n gtw = real > w\n # stw = real < w\n # condition = (gtz * gtw) + (stz * stw)\n condition = gtz * gtw\n pre_diff = w - real\n if absolute_variation:\n comp = torch.normal(pre_diff * self.scale, self.var)\n else:\n comp = torch.normal(pre_diff * self.scale, self.var_percentage * abs(pre_diff * self.scale))\n # comp = torch.clamp(comp, 0, self.max)\n new = real + comp / self.scale\n new = torch.where(condition, real, new)\n post_diff = w - new\n return new\n\n def dynamic(self, w):\n # self.sd = self.sd_percentage * self.var_percentage * w\n # pos_shift_target = w - self.sd\n # neg_shift_target = w + self.sd\n if self.absolute_variation:\n pos_real = torch.normal(w - self.sd, self.var)\n neg_real = torch.normal(w + self.sd, self.var)\n real = torch.where(w > 0, pos_real, neg_real)\n else:\n pos_real = torch.normal(w - self.sd, self.var_percentage * abs(w - self.sd))\n neg_real = torch.normal(w + self.sd, self.var_percentage * abs(w + self.sd))\n real = torch.where(w > 0, pos_real, neg_real)\n # real = torch.clamp(real, 0, self.max)\n gtz = w > torch.zeros_like(w)\n # stz = w < torch.zeros_like(w)\n gtw = real > w\n # stw = real < w\n # condition = (gtz * gtw) + (stz * stw)\n condition = gtz * gtw\n pre_diff = w - real\n if self.absolute_variation:\n comp = torch.normal(pre_diff * self.scale, self.var)\n else:\n comp = torch.normal(pre_diff * self.scale, self.var_percentage * abs(pre_diff * self.scale))\n # comp = torch.clamp(comp, 0, self.max)\n new = real + comp / self.scale\n new = torch.where(condition, real, new)\n post_diff = w - new\n return new # , real, pre_diff, post_diff\n\n def bias_comp(self, w):\n if self.absolute_variation:\n real = torch.normal(w, self.var)\n else:\n real = torch.normal(w, self.var_percentage * abs(w))\n # real = torch.clamp(real, 0, self.max)\n pre_diff = w - real\n pre_diff = torch.clamp(pre_diff, min=-self.bias)\n if self.absolute_variation:\n comp = torch.normal((pre_diff + self.bias) * self.scale, self.var)\n else:\n comp = torch.normal((pre_diff + self.bias) * self.scale,\n self.var_percentage * abs((pre_diff + self.bias) * self.scale))\n # comp = torch.where(comp > x, comp, gmin * torch.ones_like(comp))\n # comp = torch.clamp(comp, min=0)\n new = real + comp / self.scale - self.bias\n post_diff = w - new\n # return real, new, pre_diff, post_diff\n return new\n\n def double_sim(self, w):\n if self.absolute_variation:\n real = torch.normal(w, self.var)\n else:\n real = torch.normal(w, self.var_percentage * abs(w))\n # real = torch.clamp(real, 0, self.max)\n diff = w - real\n if self.absolute_variation:\n comp = torch.normal(diff * self.scale, self.var)\n else:\n comp = torch.normal(diff * self.scale, self.var_percentage * abs(diff * self.scale))\n comp = torch.clamp(comp, -self.max, self.max)\n return real + comp / self.scale\n\n\ndef multi_cell(w, k_bits, n_cells, compensation, modification=None, method=\"normal\"):\n assert k_bits % n_cells == 0, \"k_bits must be divisible by n_cells!\"\n # quantization\n if symmetric:\n num_intervals, scale = sym_quant_param(w, k_bits)\n w_q = sym_quant(w, num_intervals, scale).to(torch.int64)\n neg_mask = torch.where(w_q < 0, -1, 1)\n w_q = w_q * neg_mask\n else:\n num_intervals, scale, zero = asym_quant_param(w, k_bits)\n w_q = asym_quant(w, num_intervals, scale, zero).to(torch.int64)\n\n if n_cells > 1:\n # convert to binary digits\n mask = 2 torch.arange(k_bits - 1, -1, -1, device=w.device)\n w_binary = w_q.unsqueeze(-1).bitwise_and(mask).ne(0).int()\n\n # split into multi cells\n bits_per_cell = int(k_bits / n_cells)\n w_binary_mc = torch.chunk(w_binary, n_cells, -1)\n # get the decimal of each cell\n mask_mc = 2 torch.arange(bits_per_cell - 1, -1, -1, device=w.device)\n mask_mc = [chunk * torch.ones(w.shape, device=w.device) for chunk in mask_mc]\n mask_mc = torch.stack(mask_mc, -1)\n w_mc = [chunk.mul(mask_mc).sum(-1) for chunk in w_binary_mc]\n\n # apply variation and compensation if any\n if modification is not None:\n compensation.var = compensation.var / (2 (k_bits - bits_per_cell))\n compensation.var_percentage = compensation.var_percentage / (2 (k_bits - bits_per_cell))\n compensation.sd = compensation.sd / (2 (k_bits - bits_per_cell))\n compensation.bias = compensation.bias / (2 (k_bits - bits_per_cell))\n # variation-aware programming\n if method == \"variation_aware_programming\":\n w_mc_m = []\n vap_flag = torch.zeros_like(w_mc[0]).type(torch.bool)\n for i, chunk in enumerate(w_mc):\n cell_max = modification((2 ** bits_per_cell - 1) * torch.ones_like(chunk))\n w_mc_m.append(torch.where(vap_flag, cell_max, modification(chunk)))\n msb_diff = abs(w_mc[i] - w_mc_m[i])\n vap_flag = torch.logical_or(vap_flag, torch.where(msb_diff > 0.5, True, False))\n elif method == \"msb_only\":\n msb = [modification(w_mc[0])]\n lsb = [compensation.no_comp(chunk) for chunk in w_mc[1:]]\n w_mc_m = msb + lsb\n else:\n w_mc_m = [modification(chunk) for chunk in w_mc]\n w_mc = w_mc_m\n\n # merge multi cells into one weight\n magnitude = (2 bits_per_cell) torch.arange(n_cells - 1, -1, -1, device=w.device)\n mag_w = list(zip(w_mc, magnitude))\n w_mc_mag = [chunk[0] * chunk[1] for chunk in mag_w]\n w_q_m = torch.stack(w_mc_mag, -1).sum(-1)\n else:\n if modification is None:\n w_q_m = w_q\n else:\n w_q_m = modification(w_q.to(torch.float32))\n\n # dequantize\n if symmetric:\n w_q_m = w_q_m * neg_mask\n w_q_m_dq = sym_de_quant(w_q_m, scale)\n else:\n w_q_m_dq = asym_de_quant(w_q_m, scale, zero)\n return w_q_m_dq\n\n\ndef modify_weight(weight_dict, layer_list, k_bits, n_cells, compensation, modification=None):\n for layer in weight_dict.keys():\n # if len(re.findall(r\"(fc\|conv)\", layer)) != 0:\n if layer in layer_list:\n # visualize weight distribution\n og_weight = weight_dict[layer].detach().clone()\n if quantized:\n weight_dict[layer] = multi_cell(weight_dict[layer], k_bits, n_cells, compensation, modification)\n else:\n if modification is None:\n return\n else:\n # weight_dict[layer], ns_weight, pre_diff, post_diff = modification(weight_dict[layer])\n weight_dict[layer] = modification(weight_dict[layer])\n dq_weight = weight_dict[layer].detach().clone()\n if visualize:\n # weight_np = weight_dict[conv + '.weight'].numpy()\n # weight_np = weight_dict[layer].numpy()\n # plt.figure()\n plt.hist(og_weight.cpu().numpy().flatten(), 200, alpha=0.4, color='red', label='weight')\n # plt.hist(w_q.cpu().numpy().flatten(), 200, alpha=0.6, color='yellow', label='quantized_weight')\n plt.hist(dq_weight.cpu().numpy().flatten(), 200, alpha=0.4, color='blue', label='de_quant_weight')\n plt.legend()\n # plt.show()\n plt.savefig(\"/home/huangyc/jingyuhe/Pytorch_CIFAR10/dy_comp_weight/\" + layer + \"_weight.png\")\n plt.close()\n\n # plt.figure()\n plt.hist(pre_diff.cpu().numpy().flatten(), 200, alpha=0.4, color='purple', label='pre_comp errors')\n plt.hist(post_diff.cpu().numpy().flatten(), 200, alpha=0.4, color='yellow', label='post_comp errors')\n plt.legend()\n # plt.show()\n plt.savefig(\"/home/huangyc/jingyuhe/Pytorch_CIFAR10/dy_comp_weight/\" + layer + \"_diff.png\")\n plt.close()\n\n'''\ntmp = torch.normal(0, 0.2, size=(3, 3), device=\"cuda:0\")\ncompensation = Compensation()\nmulti_cell(tmp, 6, 3, compensation, compensation.dynamic, method=\"variation_aware_programming\")\n'''" ]	[ [ "torch.normal", "torch.abs", "torch.mean", "matplotlib.pyplot.legend", "torch.ones", "torch.max", "torch.round", "torch.min", "torch.zeros_like", "matplotlib.pyplot.savefig", "torch.where", "torch.arange", "torch.chunk", "matplotlib.pyplot.close", "torch.clamp", "torch.ones_like", "torch.stack" ] ]
Dzhange/rex-gym	[ "3ffb674ade13ceac3352c3329f1804eb21a08403" ]	[ "rex_gym/envs/gym/walk_env.py" ]	[ "\"\"\"This file implements the gym environment of rex alternating legs.\n\n\"\"\"\nimport math\nimport random\n\nfrom gym import spaces\nimport numpy as np\nfrom .. import rex_gym_env\nfrom ...model import rex_constants\nfrom ...model.gait_planner import GaitPlanner\nfrom ...model.kinematics import Kinematics\n\nNUM_LEGS = 4\n\n\nclass RexWalkEnv(rex_gym_env.RexGymEnv):\n \"\"\"The gym environment for the rex.\n\n It simulates the locomotion of a rex, a quadruped robot. The state space\n include the angles, velocities and torques for all the motors and the action\n space is the desired motor angle for each motor. The reward function is based\n on how far the rex walks in 2000 steps and penalizes the energy\n expenditure or how near rex is to the target position.\n\n \"\"\"\n metadata = {\"render.modes\": [\"human\", \"rgb_array\"], \"video.frames_per_second\": 66}\n load_ui = True\n is_terminating = False\n\n def __init__(self,\n debug=False,\n urdf_version=None,\n control_time_step=0.005,\n action_repeat=5,\n control_latency=0,\n pd_latency=0,\n on_rack=False,\n motor_kp=1.0,\n motor_kd=0.02,\n render=False,\n num_steps_to_log=2000,\n env_randomizer=None,\n log_path=None,\n target_position=None,\n backwards=None,\n signal_type=\"ik\",\n terrain_type=\"plane\",\n terrain_id=None,\n mark='base'):\n \"\"\"Initialize the rex alternating legs gym environment.\n\n Args:\n urdf_version: [DEFAULT_URDF_VERSION, DERPY_V0_URDF_VERSION] are allowable\n versions. If None, DEFAULT_URDF_VERSION is used. Refer to\n rex_gym_env for more details.\n control_time_step: The time step between two successive control signals.\n action_repeat: The number of simulation steps that an action is repeated.\n control_latency: The latency between get_observation() and the actual\n observation. See minituar.py for more details.\n pd_latency: The latency used to get motor angles/velocities used to\n compute PD controllers. See rex.py for more details.\n on_rack: Whether to place the rex on rack. This is only used to debug\n the walk gait. In this mode, the rex's base is hung midair so\n that its walk gait is clearer to visualize.\n motor_kp: The P gain of the motor.\n motor_kd: The D gain of the motor.\n remove_default_joint_damping: Whether to remove the default joint damping.\n render: Whether to render the simulation.\n num_steps_to_log: The max number of control steps in one episode. If the\n number of steps is over num_steps_to_log, the environment will still\n be running, but only first num_steps_to_log will be recorded in logging.\n env_randomizer: An instance (or a list) of EnvRanzomier(s) that can\n randomize the environment during when env.reset() is called and add\n perturbations when env.step() is called.\n log_path: The path to write out logs. For the details of logging, refer to\n rex_logging.proto.\n \"\"\"\n super(RexWalkEnv,\n self).__init__(urdf_version=urdf_version,\n accurate_motor_model_enabled=True,\n motor_overheat_protection=True,\n hard_reset=False,\n motor_kp=motor_kp,\n motor_kd=motor_kd,\n remove_default_joint_damping=False,\n control_latency=control_latency,\n pd_latency=pd_latency,\n on_rack=on_rack,\n render=render,\n num_steps_to_log=num_steps_to_log,\n env_randomizer=env_randomizer,\n log_path=log_path,\n control_time_step=control_time_step,\n action_repeat=action_repeat,\n target_position=target_position,\n signal_type=signal_type,\n backwards=backwards,\n debug=debug,\n terrain_id=terrain_id,\n terrain_type=terrain_type,\n mark=mark)\n # (eventually) allow different feedback ranges/action spaces for different signals\n action_max = {\n 'ik': 0.4,\n 'ol': 0.01\n }\n action_dim_map = {\n 'ik': 2,\n 'ol': 8\n }\n action_dim = action_dim_map[self._signal_type]\n action_high = np.array([action_max[self._signal_type]] * action_dim)\n self.action_space = spaces.Box(-action_high, action_high)\n self._cam_dist = 1.0\n self._cam_yaw = 0.0\n self._cam_pitch = -20\n self._signal_type = signal_type\n self._gait_planner = GaitPlanner(\"walk\")\n self._kinematics = Kinematics()\n self.goal_reached = False\n self._stay_still = False\n self.is_terminating = False\n\n def reset(self):\n self.init_pose = rex_constants.INIT_POSES[\"stand\"]\n if self._signal_type == 'ol':\n self.init_pose = rex_constants.INIT_POSES[\"stand_ol\"]\n super(RexWalkEnv, self).reset(initial_motor_angles=self.init_pose, reset_duration=0.5)\n self.goal_reached = False\n self.is_terminating = False\n self._stay_still = False\n if self._backwards is None:\n self.backwards = random.choice([True, False])\n else:\n self.backwards = self._backwards\n step = 0.6\n period = 0.65\n base_x = self._base_x\n if self.backwards:\n step = -.3\n period = .5\n base_x = .0\n if not self._target_position or self._random_pos_target:\n bound = -3 if self.backwards else 3\n self._target_position = random.uniform(bound//2, bound)\n self._random_pos_target = True\n if 1 or (self._is_render and self._signal_type == 'ik'):\n if self.load_ui:\n self.setup_ui(base_x, step, period)\n self.load_ui = False\n if self._is_debug:\n print(f\"Target Position x={self._target_position}, Random assignment: {self._random_pos_target}, Backwards: {self.backwards}\")\n return self._get_observation()\n\n def setup_ui(self, base_x, step, period):\n self.base_x_ui = self._pybullet_client.addUserDebugParameter(\"base_x\",\n self._ranges[\"base_x\"][0],\n self._ranges[\"base_x\"][1],\n base_x)\n self.base_y_ui = self._pybullet_client.addUserDebugParameter(\"base_y\",\n self._ranges[\"base_y\"][0],\n self._ranges[\"base_y\"][1],\n self._ranges[\"base_y\"][2])\n self.base_z_ui = self._pybullet_client.addUserDebugParameter(\"base_z\",\n self._ranges[\"base_z\"][0],\n self._ranges[\"base_z\"][1],\n self._ranges[\"base_z\"][2])\n self.roll_ui = self._pybullet_client.addUserDebugParameter(\"roll\",\n self._ranges[\"roll\"][0],\n self._ranges[\"roll\"][1],\n self._ranges[\"roll\"][2])\n self.pitch_ui = self._pybullet_client.addUserDebugParameter(\"pitch\",\n self._ranges[\"pitch\"][0],\n self._ranges[\"pitch\"][1],\n self._ranges[\"pitch\"][2])\n self.yaw_ui = self._pybullet_client.addUserDebugParameter(\"yaw\",\n self._ranges[\"yaw\"][0],\n self._ranges[\"yaw\"][1],\n self._ranges[\"yaw\"][2])\n self.step_length_ui = self._pybullet_client.addUserDebugParameter(\"step_length\", -0.7, 0.7, step)\n self.step_rotation_ui = self._pybullet_client.addUserDebugParameter(\"step_rotation\", -1.5, 1.5, 0.)\n self.step_angle_ui = self._pybullet_client.addUserDebugParameter(\"step_angle\", -180., 180., 0.)\n self.step_period_ui = self._pybullet_client.addUserDebugParameter(\"step_period\", 0.2, 0.9, period)\n\n def _read_inputs(self, base_pos_coeff, gait_stage_coeff):\n position = np.array(\n [\n self._pybullet_client.readUserDebugParameter(self.base_x_ui),\n self._pybullet_client.readUserDebugParameter(self.base_y_ui) * base_pos_coeff,\n self._pybullet_client.readUserDebugParameter(self.base_z_ui) * base_pos_coeff\n ]\n )\n orientation = np.array(\n [\n self._pybullet_client.readUserDebugParameter(self.roll_ui) * base_pos_coeff,\n self._pybullet_client.readUserDebugParameter(self.pitch_ui) * base_pos_coeff,\n self._pybullet_client.readUserDebugParameter(self.yaw_ui) * base_pos_coeff\n ]\n )\n step_length = self._pybullet_client.readUserDebugParameter(self.step_length_ui) * gait_stage_coeff\n step_rotation = self._pybullet_client.readUserDebugParameter(self.step_rotation_ui)\n step_angle = self._pybullet_client.readUserDebugParameter(self.step_angle_ui)\n step_period = self._pybullet_client.readUserDebugParameter(self.step_period_ui)\n return position, orientation, step_length, step_rotation, step_angle, step_period\n\n def _check_target_position(self, t):\n if self._target_position:\n current_x = abs(self.rex.GetBasePosition()[0])\n # give 0.15 stop space\n if current_x >= abs(self._target_position) - 0.15:\n self.goal_reached = True\n if not self.is_terminating:\n self.end_time = t\n self.is_terminating = True\n\n @staticmethod\n def _evaluate_base_stage_coeff(current_t, end_t=0.0, width=0.001):\n # sigmoid function\n beta = p = width\n if p - beta + end_t <= current_t <= p - (beta / 2) + end_t:\n return (2 / beta ** 2) * (current_t - p + beta) 2\n elif p - (beta/2) + end_t <= current_t <= p + end_t:\n return 1 - (2 / beta 2) * (current_t - p) ** 2\n else:\n return 1\n\n @staticmethod\n def _evaluate_gait_stage_coeff(current_t, action, end_t=0.0):\n # ramp function\n p = 0.8 + action[0]\n if end_t <= current_t <= p + end_t:\n return current_t\n else:\n return 1.0\n\n @staticmethod\n def _evaluate_brakes_stage_coeff(current_t, action, end_t=0.0, end_value=0.0):\n # ramp function\n p = 0.8 + action[1]\n if end_t <= current_t <= p + end_t:\n return 1 - (current_t - end_t)\n else:\n return end_value\n\n def _signal(self, t, action):\n if self._signal_type == 'ik':\n return self._IK_signal(t, action)\n if self._signal_type == 'ol':\n return self._open_loop_signal(t, action)\n\n def _IK_signal(self, t, action):\n base_pos_coeff = self._evaluate_base_stage_coeff(t, width=1.5)\n gait_stage_coeff = self._evaluate_gait_stage_coeff(t, action)\n step = 0.6\n period = 0.65\n base_x = self._base_x\n if self.backwards:\n step = -.3\n period = .5\n base_x = .0\n if (self._is_render and self._is_debug):\n position, orientation, step_length, step_rotation, step_angle, step_period = \\\n self._read_inputs(base_pos_coeff, gait_stage_coeff)\n # elif 0 and self._is_debug:\n # # print(\"here\")\n # position = np.array([base_x,\n # self._base_y * base_pos_coeff,\n # self._base_z * base_pos_coeff])\n # orientation = np.array([self._base_roll * base_pos_coeff,\n # self._base_pitch * base_pos_coeff,\n # self._base_yaw * base_pos_coeff])\n # step_length = -0.3\n # step_rotation = 0\n # step_angle = 0\n # step_period = 0.5 \n else:\n position = np.array([base_x,\n self._base_y * base_pos_coeff,\n self._base_z * base_pos_coeff])\n orientation = np.array([self._base_roll * base_pos_coeff,\n self._base_pitch * base_pos_coeff,\n self._base_yaw * base_pos_coeff])\n step_length = (self.step_length if self.step_length is not None else step) * gait_stage_coeff\n step_rotation = (self.step_rotation if self.step_rotation is not None else 0.0)\n step_angle = self.step_angle if self.step_angle is not None else 0.0\n step_period = (self.step_period if self.step_period is not None else period)\n # print(position, orientation, step_length, step_rotation, step_angle, step_period)\n if self.goal_reached:\n brakes_coeff = self._evaluate_brakes_stage_coeff(t, action, self.end_time)\n step_length = brakes_coeff\n if brakes_coeff == 0.0:\n self._stay_still = True\n direction = -1.0 if step_length < 0 else 1.0\n frames = self._gait_planner.loop(step_length, step_angle, step_rotation, step_period, direction)\n fr_angles, fl_angles, rr_angles, rl_angles, _ = self._kinematics.solve(orientation, position, frames)\n signal = [\n fl_angles[0], fl_angles[1], fl_angles[2],\n fr_angles[0], fr_angles[1], fr_angles[2],\n rl_angles[0], rl_angles[1], rl_angles[2],\n rr_angles[0], rr_angles[1], rr_angles[2]\n ]\n return signal\n\n def _open_loop_signal(self, t, action):\n period = 1.0 / 8\n l_a = 0.1\n f_a = l_a 2\n if self.goal_reached:\n coeff = self._evaluate_brakes_stage_coeff(t, [0., 0.], end_t=self.end_time, end_value=0.0)\n l_a = coeff\n f_a = coeff\n if coeff is 0.0:\n self._stay_still = True\n start_coeff = self._evaluate_gait_stage_coeff(t, [0.0])\n l_a = start_coeff\n f_a = start_coeff\n l_extension = l_a * math.cos(2 * math.pi / period * t)\n f_extension = f_a * math.cos(2 * math.pi / period * t)\n initial_pose = self.init_pose\n l_swing = -l_extension\n swing = -f_extension\n pose = np.array([0.0, l_extension + action[0], f_extension + action[1],\n 0.0, l_swing + action[2], swing + action[3],\n 0.0, l_swing + action[4], swing + action[5],\n 0.0, l_extension + action[6], f_extension + action[7]])\n signal = initial_pose + pose\n return signal\n\n def _transform_action_to_motor_command(self, action):\n if self._stay_still:\n return self.init_pose\n t = self.rex.GetTimeSinceReset()\n self._check_target_position(t)\n action = self._signal(t, action)\n action = super(RexWalkEnv, self)._transform_action_to_motor_command(action)\n return action\n\n def is_fallen(self):\n \"\"\"Decide whether the rex has fallen.\n\n If the up directions between the base and the world is large (the dot\n product is smaller than 0.85), the rex is considered fallen.\n\n Returns:\n Boolean value that indicates whether the rex has fallen.\n \"\"\"\n orientation = self.rex.GetBaseOrientation()\n rot_mat = self._pybullet_client.getMatrixFromQuaternion(orientation)\n local_up = rot_mat[6:]\n return np.dot(np.asarray([0, 0, 1]), np.asarray(local_up)) < 0.85\n\n def _get_true_observation(self):\n \"\"\"Get the true observations of this environment.\n\n It includes the roll, the error between current pitch and desired pitch,\n roll dot and pitch dot of the base.\n\n Returns:\n The observation list.\n \"\"\"\n observation = []\n roll, pitch, _ = self.rex.GetTrueBaseRollPitchYaw()\n roll_rate, pitch_rate, _ = self.rex.GetTrueBaseRollPitchYawRate()\n observation.extend([roll, pitch, roll_rate, pitch_rate])\n self._true_observation = np.array(observation)\n return self._true_observation\n\n def _get_observation(self):\n observation = []\n roll, pitch, _ = self.rex.GetBaseRollPitchYaw()\n roll_rate, pitch_rate, _ = self.rex.GetBaseRollPitchYawRate()\n observation.extend([roll, pitch, roll_rate, pitch_rate])\n self._observation = np.array(observation)\n return self._observation\n\n def _get_observation_upper_bound(self):\n \"\"\"Get the upper bound of the observation.\n\n Returns:\n The upper bound of an observation. See GetObservation() for the details\n of each element of an observation.\n \"\"\"\n upper_bound = np.zeros(self._get_observation_dimension())\n upper_bound[0:2] = 2 * math.pi # Roll, pitch, yaw of the base.\n upper_bound[2:4] = 2 * math.pi / self._time_step # Roll, pitch, yaw rate.\n return upper_bound\n\n def _get_observation_lower_bound(self):\n lower_bound = -self._get_observation_upper_bound()\n return lower_bound\n" ]	[ [ "numpy.asarray", "numpy.array" ] ]
cabbagerice/word-chain	[ "5d2978df61a7136f502b1b601213e97454103e1e" ]	[ "kakunin.py" ]	[ "import firebase_admin\nfrom firebase_admin import credentials\nfrom firebase_admin import db\nfrom numpy import random as unko\nimport math\n\n\n#認証ファイルPATH\ncertificate_json_path='secret.json'\n#DBとアプリへの認証\nif (not len(firebase_admin._apps)):\n\tcred = credentials.Certificate(certificate_json_path) \n\tdefault_app = firebase_admin.initialize_app(cred, {\n\t'databaseURL': 'https://wordchain-bfb8b.firebaseio.com/'\n\t})\nprint(db.reference(\"/PDD_hum/あ/\"+ str(math.floor(unko.rand()*1000))).get());exit()" ]	[ [ "numpy.random.rand" ] ]
weihao94/keras-YOLOv3-model-set	[ "7b54809d5f5513a41a191289625612d71056e3ec" ]	[ "yolo2/models/layers.py" ]	[ "#!/usr/bin/env python3\n# -- coding: utf-8 --\n\"\"\"\nCommon layer definition for YOLOv2 models building\n\"\"\"\nfrom functools import wraps, reduce, partial\n\nimport tensorflow.keras.backend as K\nfrom tensorflow.keras.layers import Conv2D, DepthwiseConv2D, MaxPooling2D, Concatenate, Lambda\nfrom tensorflow.keras.layers import LeakyReLU\nfrom tensorflow.keras.layers import BatchNormalization\nfrom tensorflow.keras.regularizers import l2\n\nfrom common.backbones.layers import CustomBatchNormalization\n\n# Partial wrapper for Convolution2D with static default argument.\n_DarknetConv2D = partial(Conv2D, padding='same')\n\n\ndef compose(funcs):\n \"\"\"Compose arbitrarily many functions, evaluated left to right.\n\n Reference: https://mathieularose.com/function-composition-in-python/\n \"\"\"\n # return lambda x: reduce(lambda v, f: f(v), funcs, x)\n if funcs:\n return reduce(lambda f, g: lambda a, *kw: g(f(a, *kw)), funcs)\n else:\n raise ValueError('Composition of empty sequence not supported.')\n\n\n@wraps(Conv2D)\ndef DarknetConv2D(args, *kwargs):\n \"\"\"Wrapper to set Darknet weight regularizer for Convolution2D.\"\"\"\n darknet_conv_kwargs = {'kernel_regularizer': l2(5e-4)}\n darknet_conv_kwargs.update(kwargs)\n return _DarknetConv2D(args, *darknet_conv_kwargs)\n\n@wraps(DepthwiseConv2D)\ndef DarknetDepthwiseConv2D(args, *kwargs):\n \"\"\"Wrapper to set Darknet parameters for Convolution2D.\"\"\"\n darknet_conv_kwargs = {'kernel_regularizer': l2(5e-4)}\n darknet_conv_kwargs['padding'] = 'valid' if kwargs.get('strides')==(2,2) else 'same'\n darknet_conv_kwargs.update(kwargs)\n return DepthwiseConv2D(args, darknet_conv_kwargs)\n\n\ndef Darknet_Depthwise_Separable_Conv2D_BN_Leaky(filters, kernel_size=(3, 3), block_id_str=None, kwargs):\n \"\"\"Depthwise Separable Convolution2D.\"\"\"\n if not block_id_str:\n block_id_str = str(K.get_uid())\n no_bias_kwargs = {'use_bias': False}\n no_bias_kwargs.update(kwargs)\n return compose(\n DarknetDepthwiseConv2D(kernel_size, name='conv_dw_' + block_id_str, *no_bias_kwargs),\n CustomBatchNormalization(name='conv_dw_%s_bn' % block_id_str),\n LeakyReLU(alpha=0.1, name='conv_dw_%s_leaky_relu' % block_id_str),\n Conv2D(filters, (1,1), padding='same', use_bias=False, strides=(1, 1), name='conv_pw_%s' % block_id_str),\n CustomBatchNormalization(name='conv_pw_%s_bn' % block_id_str),\n LeakyReLU(alpha=0.1, name='conv_pw_%s_leaky_relu' % block_id_str))\n\n\ndef Depthwise_Separable_Conv2D_BN_Leaky(filters, kernel_size=(3, 3), block_id_str=None):\n \"\"\"Depthwise Separable Convolution2D.\"\"\"\n if not block_id_str:\n block_id_str = str(K.get_uid())\n return compose(\n DepthwiseConv2D(kernel_size, padding='same', name='conv_dw_' + block_id_str),\n CustomBatchNormalization(name='conv_dw_%s_bn' % block_id_str),\n LeakyReLU(alpha=0.1, name='conv_dw_%s_leaky_relu' % block_id_str),\n Conv2D(filters, (1,1), padding='same', use_bias=False, strides=(1, 1), name='conv_pw_%s' % block_id_str),\n CustomBatchNormalization(name='conv_pw_%s_bn' % block_id_str),\n LeakyReLU(alpha=0.1, name='conv_pw_%s_leaky_relu' % block_id_str))\n\n\ndef DarknetConv2D_BN_Leaky(args, *kwargs):\n \"\"\"Darknet Convolution2D followed by CustomBatchNormalization and LeakyReLU.\"\"\"\n no_bias_kwargs = {'use_bias': False}\n no_bias_kwargs.update(kwargs)\n return compose(\n DarknetConv2D(args, *no_bias_kwargs),\n CustomBatchNormalization(),\n LeakyReLU(alpha=0.1))\n\n\ndef bottleneck_block(outer_filters, bottleneck_filters):\n \"\"\"Bottleneck block of 3x3, 1x1, 3x3 convolutions.\"\"\"\n return compose(\n DarknetConv2D_BN_Leaky(outer_filters, (3, 3)),\n DarknetConv2D_BN_Leaky(bottleneck_filters, (1, 1)),\n DarknetConv2D_BN_Leaky(outer_filters, (3, 3)))\n\n\ndef bottleneck_x2_block(outer_filters, bottleneck_filters):\n \"\"\"Bottleneck block of 3x3, 1x1, 3x3, 1x1, 3x3 convolutions.\"\"\"\n return compose(\n bottleneck_block(outer_filters, bottleneck_filters),\n DarknetConv2D_BN_Leaky(bottleneck_filters, (1, 1)),\n DarknetConv2D_BN_Leaky(outer_filters, (3, 3)))\n\n\ndef space_to_depth_x2(x):\n \"\"\"Thin wrapper for Tensorflow space_to_depth with block_size=2.\"\"\"\n # Import currently required to make Lambda work.\n # See: https://github.com/fchollet/keras/issues/5088#issuecomment-273851273\n import tensorflow as tf\n return tf.nn.space_to_depth(x, block_size=2)\n\n\ndef space_to_depth_x2_output_shape(input_shape):\n \"\"\"Determine space_to_depth output shape for block_size=2.\n\n Note: For Lambda with TensorFlow backend, output shape may not be needed.\n \"\"\"\n return (input_shape[0], input_shape[1] // 2, input_shape[2] // 2, 4 \n input_shape[3]) if input_shape[1] else (input_shape[0], None, None,\n 4 * input_shape[3])\n\ndef yolo2_predictions(feature_maps, feature_channel_nums, num_anchors, num_classes):\n f1, f2 = feature_maps\n f1_channel_num, f2_channel_num = feature_channel_nums\n\n x1 = compose(\n DarknetConv2D_BN_Leaky(f1_channel_num, (3, 3)),\n DarknetConv2D_BN_Leaky(f1_channel_num, (3, 3)))(f1)\n\n # Here change the f2 channel number to f2_channel_num//8 first,\n # then expand back to f2_channel_num//2 with \"space_to_depth_x2\"\n x2 = DarknetConv2D_BN_Leaky(f2_channel_num//8, (1, 1))(f2)\n # TODO: Allow Keras Lambda to use func arguments for output_shape?\n x2_reshaped = Lambda(\n space_to_depth_x2,\n output_shape=space_to_depth_x2_output_shape,\n name='space_to_depth')(x2)\n\n x = Concatenate()([x2_reshaped, x1])\n x = DarknetConv2D_BN_Leaky(f1_channel_num, (3, 3))(x)\n y = DarknetConv2D(num_anchors * (num_classes + 5), (1, 1), name='predict_conv')(x)\n\n return y\n\n\ndef yolo2lite_predictions(feature_maps, feature_channel_nums, num_anchors, num_classes):\n f1, f2 = feature_maps\n f1_channel_num, f2_channel_num = feature_channel_nums\n\n x1 = compose(\n Depthwise_Separable_Conv2D_BN_Leaky(filters=f1_channel_num, kernel_size=(3, 3), block_id_str='pred_1'),\n Depthwise_Separable_Conv2D_BN_Leaky(filters=f1_channel_num, kernel_size=(3, 3), block_id_str='pred_2'))(f1)\n\n # Here change the f2 channel number to f2_channel_num//8 first,\n # then expand back to f2_channel_num//2 with \"space_to_depth_x2\"\n x2 = DarknetConv2D_BN_Leaky(f2_channel_num//8, (1, 1))(f2)\n # TODO: Allow Keras Lambda to use func arguments for output_shape?\n x2_reshaped = Lambda(\n space_to_depth_x2,\n output_shape=space_to_depth_x2_output_shape,\n name='space_to_depth')(x2)\n\n x = Concatenate()([x2_reshaped, x1])\n x = Depthwise_Separable_Conv2D_BN_Leaky(filters=f1_channel_num, kernel_size=(3, 3), block_id_str='pred_3')(x)\n y = DarknetConv2D(num_anchors * (num_classes + 5), (1, 1), name='predict_conv')(x)\n\n return y\n\n" ]	[ [ "tensorflow.keras.layers.DepthwiseConv2D", "tensorflow.keras.layers.Concatenate", "tensorflow.keras.layers.LeakyReLU", "tensorflow.keras.layers.Lambda", "tensorflow.keras.regularizers.l2", "tensorflow.keras.layers.Conv2D", "tensorflow.nn.space_to_depth", "tensorflow.keras.backend.get_uid" ] ]
mxndrwgrdnr/evictions	[ "bf59bfe98903c2aa839daf7597951dc36cdecaad" ]	[ "scripts/get_assessor_data.py" ]	[ "#######################################################\n# script to compile and standardize raw assessor data #\n#######################################################\n\n\nimport pandas as pd\nfrom tqdm import tqdm\nfrom geopy.geocoders import Nominatim\nfrom geopy.extra.rate_limiter import RateLimiter\nimport numpy as np\nimport geopandas as gpd\nfrom matplotlib import pyplot as plt\n\n# only use 10 years of history\nfiles = [\n # '../data/2019.8.12__SF_ASR_Secured_Roll_Data_2017-2018_0.xlsx',\n '../data/2019.8.12__SF_ASR_Secured_Roll_Data_2016-2017_0.xlsx',\n '../data/2019.8.12__SF_ASR_Secured_Roll_Data_2015-2016_0.xlsx',\n '../data/2019.8.20__SF_ASR_Secured_Roll_Data_2014-2015.xlsx',\n '../data/2019.8.20__SF_ASR_Secured_Roll_Data_2013-2014.xlsx',\n '../data/2019.8.20__SF_ASR_Secured_Roll_Data_2012-2013.xlsx',\n '../data/2019.8.20__SF_ASR_Secured_Roll_Data_2011-2012.xlsx',\n '../data/2019.8.20__SF_ASR_Secured_Roll_Data_2010-2011.xlsx',\n '../data/2019.8.20__SF_ASR_Secured_Roll_Data_2009-2010.xlsx',\n '../data/2019.8.20__SF_ASR_Secured_Roll_Data_2008-2009.xlsx',\n '../data/2019.8.20__SF_ASR_Secured_Roll_Data_2007-2008.xlsx',\n]\n\nyears = [\n # 2017,\n 2016, 2015, 2014, 2013, 2012, 2011, 2010, 2009, 2008, 2007]\n\nasr = pd.DataFrame()\n\nfor i, f in tqdm(enumerate(files), total=len(files)):\n\n tmp = pd.read_excel(f, engine='openpyxl')\n tmp['asr_yr'] = years[i]\n asr = pd.concat((asr, tmp), sort=True)\n\ncodes = pd.read_csv('../data/Reference__Assessor-Recorder_Property_Class_Codes.csv')\ncode_dict = dict(zip(codes['Class Code'], codes['Use Code']))\nrc_dict = dict(zip(codes['Class Code'], codes['rc_eligible'])) \n\nasr['use_code'] = asr['RP1CLACDE'].map(code_dict)\nasr['rc_eligible'] = asr['RP1CLACDE'].map(rc_dict)\nasr.loc[asr['RP1PRCLID'].isin(['1530 035', '1530 036']), 'PROPLOC'] = '0411 0409 14TH AV0000'\nasr.loc[asr['RP1PRCLID'].isin(['1432 061', '1432 060']), 'PROPLOC'] = '0355 0353 ARGUELLO BL0000'\nasr.loc[asr['RP1PRCLID'].isin(['1744 031', '1744 032']), 'PROPLOC'] = '0506 0504 HUGO ST0000'\nasr.loc[asr['RP1PRCLID'].isin(['1254 098', '1254 097']), 'PROPLOC'] = '0083 0081 DOWNEY ST0000'\nasr.loc[asr['RP1PRCLID'].isin(['0942 051', '0942 052']), 'PROPLOC'] = '2794 2792 FILBERT ST0000'\nasr.loc[asr['RP1PRCLID'] == '1187 016', 'PROPLOC'] = '0000 0048 ASHBURY ST0000'\nasr.loc[asr['RP1PRCLID'] == '1187 017', 'PROPLOC'] = '0000 0050 ASHBURY ST0000'\nasr.loc[asr['RP1PRCLID'].isin(\n ['3730 188', '3730 189', '3730 190', '3730 191', '3730 192']), 'PROPLOC'] = '0000 0019 RAUSCH ST0000'\nasr.loc[asr['RP1PRCLID'] == '3630 031', 'PROPLOC'] = '0175 0175 CHATTANOOGA ST0000'\nasr.loc[asr['RP1PRCLID'] == '3630 032', 'PROPLOC'] = '0177 0177 CHATTANOOGA ST0000'\nasr.loc[asr['RP1PRCLID'] == '3630 033', 'PROPLOC'] = '0179 0179 CHATTANOOGA ST0000'\nasr.loc[asr['RP1PRCLID'] == '3630 030', 'PROPLOC'] = '0173 0173 CHATTANOOGA ST0000'\nasr.loc[asr['RP1PRCLID'] == '3731 242', 'PROPLOC'] = '0000 0038 MOSS ST0000'\n\n\nasr = asr[asr['PROPLOC'] != '0000 0000 0000']\n\nasr['house_1'] = asr['PROPLOC'].str[0:4].str.lstrip('0')\nasr['house_2'] = asr['PROPLOC'].str[5:9].str.lstrip('0')\n\nasr['house_1'] = asr['house_1'].str.replace('\\D', '')\nasr.loc[asr['house_1'] == '', 'house_1'] = -999\nasr['house_2'] = asr['house_2'].str.replace('\\D', '')\n\nasr = asr[asr['house_2'] != '']\nasr = asr[~asr['PROPLOC'].str.contains('SITUS TO BE ASSIGNED')]\n\nasr['street_name'] = asr['PROPLOC'].str[10:].str.strip().str.split(' ').str[:-1].str.join(' ').str.strip().str.lstrip('0')\nasr['street_rest'] = asr['PROPLOC'].str[10:].str.strip().str.split(' ').str[-1].str.strip()\n\nasr['street_type'] = None\nasr['unit_num'] = None\n\nasr.loc[asr['street_rest'].str.len().isin([6, 7]), 'street_type'] = asr.loc[\n asr['street_rest'].str.len().isin([6, 7]), 'street_rest'].str[0:2]\nasr.loc[asr['street_rest'].str.len().isin([6, 7]), 'unit_num'] = asr.loc[\n asr['street_rest'].str.len().isin([6, 7]), 'street_rest'].str[2:]\nasr.loc[asr['street_rest'].str.len().isin([4, 5]), 'unit_num'] = asr.loc[\n asr['street_rest'].str.len().isin([4, 5]), 'street_rest']\n\nasr.loc[asr['PROPLOC'].str.contains(\n 'NORTH POINT'), 'street_name'] = 'NORTH POINT'\nasr.loc[asr['PROPLOC'].str.contains(\n 'NORTH POINT'), 'street_type'] = 'ST'\n\nasr.loc[asr['street_name'].str.contains('\\sAVE$\|\\sAVENUE$\|\\sSTREET$\|\\sST$'), 'street_type'] = asr.loc[\n asr['street_name'].str.contains('\\sAVE$\|\\sAVENUE$\|\\sSTREET$\|\\sST$'),\n 'street_name'].str.extract('(\\sAVE$\|\\sAVENUE$\|\\sSTREET$\|\\sST$)', expand=False).str.strip().str[0:2]\nasr.loc[asr['street_name'].str.contains('\\sAVE$\|\\sAVENUE$\|\\sSTREET$\|\\sST$'), 'street_name'] = asr.loc[\n asr['street_name'].str.contains('\\sAVE$\|\\sAVENUE$\|\\sSTREET$\|\\sST$'), 'street_name'].str.split(\n '\\sAVE$\|\\sAVENUE$\|\\sSTREET$\|\\sST$').str[0]\n\nasr.loc[(~pd.isnull(asr['street_name'])) & (asr['street_name'].str.contains(\n '\\sSTT$\|\\sSTIT$\|\\sSTITE$\|\\sSTNIT$')), 'street_type'] = 'street'\nasr.loc[(~pd.isnull(asr['street_name'])) & (asr['street_name'].str.contains('\\sSTT$\|\\sSTIT$\|\\sSTITE$\|\\sSTNIT$')), 'street_name'] = asr.loc[\n (~pd.isnull(asr['street_name'])) & \n (asr['street_name'].str.contains('\\sSTT$\|\\sSTIT$\|\\sSTITE$\|\\sSTNIT$')), 'street_name'].str.split(\n '\\sSTT$\|\\sSTIT$\|\\sSTITE$\|\\sSTNIT$').str[0].str.strip()\n\nasr.loc[asr['street_name'].str.contains('\\sNOR$'), 'street_type'] = 'BLVD'\nasr.loc[asr['street_name'].str.contains('FARRELL'), 'street_name'] = 'OFARRELL'\nasr.loc[asr['street_name'] == 'EDINBURG', 'street_name'] = 'EDINBURGH'\nasr.loc[asr['street_name'] == 'EDINBURG', 'street_type'] = 'ST'\nasr.loc[asr['PROPLOC'].str.contains('.SO.VAN NESS.'), 'street_name'] = 'SOUTH VAN NESS'\nasr.loc[asr['PROPLOC'].str.contains('.SO.VAN NESS.'), 'street_type'] = 'AVE'\nasr.loc[asr['PROPLOC'].str.contains('BROADWAY'), 'street_type'] = 'ST'\n\n# for pre in ['A', 'B', 'C']:\n# for street in ['COLLINGWOOD', 'HAYES', 'MASONIC', 'RODGERS']:\n# asr.loc[asr['street_name'] == pre + street, 'street_name'] = street\n# for pre in ['A', 'B']:\n# for street in [\n# # 'CHURCH', 'UPPER', '14TH', 'FOLSOM', 'PINE', 'FREDERICK', 'PROSPECT', 'HARPER', 'PARNASSUS',\n# # 'MACONDRAY',\n# 'STANYAN']:\n# asr.loc[asr['street_name'] == pre + street, 'street_name'] = street\n# for pre in ['A']:\n# for street in ['DOWNEY', 'CLINTON PARK']:\n# asr.loc[asr['street_name'] == pre + street, 'street_name'] = street\n\n# many streets have 4 digit street numbers with trailing zeros not present in the eviction records\n\n# asr.loc[(asr['street_name'] == 'FREDERICK') & (asr['house_2'].astype(str).str.len() == 4), 'house_2'] = \\\n# asr.loc[(asr['street_name'] == 'FREDERICK') & (asr['house_2'].astype(str).str.len() == 4), 'house_2'].str[0:3]\n# asr.loc[(asr['street_name'] == 'FREDERICK') & (asr['house_1'].astype(str).str.len() == 4), 'house_1'] = \\\n# asr.loc[(asr['street_name'] == 'FREDERICK') & (asr['house_1'].astype(str).str.len() == 4), 'house_1'].str[0:3]\n# asr.loc[(asr['street_name'] == 'DOWNEY') & (asr['house_2'].astype(str).str.len() == 4), 'house_2'] = \\\n# asr.loc[(asr['street_name'] == 'DOWNEY') & (asr['house_2'].astype(str).str.len() == 4), 'house_2'].str[0:3]\n# asr.loc[(asr['street_name'] == 'BELVEDERE') & (asr['house_2'].astype(str).str.len() == 4), 'house_2'] = \\\n# asr.loc[(asr['street_name'] == 'BELVEDERE') & (asr['house_2'].astype(str).str.len() == 4), 'house_2'].str[0:3]\n# asr.loc[(asr['street_name']=='SHRADER') & (asr['house_2'] > 2000) & (asr['house_2'].astype(str).str[-1] == '0'), 'house_2'] = \\\n# asr.loc[(asr['street_name']=='SHRADER') & (asr['house_2'] > 2000) & (asr['house_2'].astype(str).str[-1] == '0'), 'house_2'].str[0:3]\n# asr.loc[(asr['street_name']=='SHRADER') & (asr['house_1'] > 2000) & (asr['house_1'].astype(str).str[-1] == '0'), 'house_1'] = \\\n# asr.loc[(asr['street_name']=='SHRADER') & (asr['house_1'] > 2000) & (asr['house_1'].astype(str).str[-1] == '0'), 'house_1'].str[0:3]\n# asr.loc[(asr['street_name']=='WALLER') & (asr['house_2'] > 1000) & (asr['house_2'].astype(str).str[-1] == '0'), 'house_2'] = \\\n# asr.loc[(asr['street_name']=='WALLER') & (asr['house_2'] > 1000) & (asr['house_2'].astype(str).str[-1] == '0'), 'house_2'].str[0:3]\n# asr.loc[(asr['street_name']=='WALLER') & (asr['house_1'] > 1000) & (asr['house_1'].astype(str).str[-1] == '0'), 'house_1'] = \\\n# asr.loc[(asr['street_name']=='WALLER') & (asr['house_1'] > 1000) & (asr['house_1'].astype(str).str[-1] == '0'), 'house_1'].str[0:3]\n\nasr.loc[asr['street_name'].str.contains('^VALLEY.*F$'), 'street_name'] = 'VALLEY'\n\n# # a bunch of street names have an erroneous letter \"V\" appended to the beginning\n# asr.loc[(~pd.isnull(asr['street_name'])) & (asr['street_name'].str.contains('^V[^AEIOU]')), 'street_name'] = \\\n# asr.loc[(~pd.isnull(asr['street_name'])) & (asr['street_name'].str.contains('^V[^AEIOU]')), 'street_name'].str[1:]\n# other_weird_vnames = [\n# 'VELSIE', 'VUNDERWOOD', 'VEDGEHILL', 'VEGBERT', 'VOAKDALE', 'VANDOVER',\n# 'VINGERSON', 'VERVINE', 'VEDDY', 'VEVANS', 'VUNION', 'VALEMANY',\n# 'VARMSTRONG', 'VELMIRA', 'VIRVING', 'VOCEAN', 'VESMERALDA', 'VELLSWORTH',\n# 'VORIZABA', 'VALABAMA', 'VARGUELLO', 'VATHENS', 'VOAK', 'VELLIS',\n# 'VORTEGA', 'VALBERTA', 'VUPPER', 'VINGALLS', 'VELIZABETH', 'VARBOR',\n# 'VINDIANA', 'VUNIVERSITY', 'VEUCALYPTUS', 'VAPOLLO', 'VULLOA', 'VALADDIN',\n# 'VEATON', 'VEDGEWOOD', 'VERIE', 'VAQUAVISTA', 'VALTA', 'VALTON', 'VOTSEGO',\n# 'VORD', 'VAPTOS', 'VEXETER', 'VOCTAVIA', 'VURBANO', 'VAGNON', 'VOGDEN',\n# 'VASHTON', 'VAUSTIN', 'VASHBURY', 'VABBEY', 'VALDER', 'VARKANSAS',\n# 'VOAK GROVE', 'VARCH', 'VEDGAR', 'VILLINOIS', 'VARLETA']\n# asr.loc[asr['street_name'].isin(other_weird_vnames), 'street_name'] = \\\n# asr.loc[asr['street_name'].isin(other_weird_vnames), 'street_name'].str[1:]\n\nst_typ_dict = {'street': 'ST', 'AV': 'AVE', 'BL': 'BLVD', 'WY': 'WAY',\n 'TE': 'TER', 'PK': 'PARK', 'HW': 'HWY', 'LANE': 'LN', 'AL': 'ALY',\n 'CR': 'CIR', 'LA': 'LN', 'PZ': 'PLZ', 'TR': 'TER', 'RW': 'ROW', 'BV': 'BLVD',\n 'WK': 'WALK'}\nasr = asr.replace({'street_type': st_typ_dict})\n\n\nbldg_typ_dict = {'SRES': 1, 'GOVT': 2, 'IND': 3, 'COMM': 4,\n 'COMR': 5, 'COMO': 6, 'COMH': 7, 'MISC': 8, 'MRES': 9}\n\nasr['bldg_type'] = asr.replace({'use_code': bldg_typ_dict})['use_code']\n\n#\n\nasr.to_csv('../data/assessor_2007-2016.csv', index=False)" ]	[ [ "pandas.concat", "pandas.read_excel", "pandas.read_csv", "pandas.isnull", "pandas.DataFrame" ] ]
MaximumEntropy/pytorch-lightning	[ "d8c501b22bc2c02a4bedb8b686daa5f904d6cf23" ]	[ "pytorch_lightning/trainer/data_loading.py" ]	[ "# Copyright The PyTorch Lightning team.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\nimport inspect\nimport multiprocessing\nimport os\nfrom abc import ABC\nfrom copy import deepcopy\nfrom functools import partial\nfrom typing import Any, Callable, Dict, List, Optional, Tuple, Union\n\nfrom torch.utils.data import BatchSampler, DataLoader, RandomSampler, Sampler, SequentialSampler\nfrom torch.utils.data.dataset import IterableDataset\nfrom torch.utils.data.distributed import DistributedSampler\n\nimport pytorch_lightning as pl\nfrom pytorch_lightning.accelerators import Accelerator\nfrom pytorch_lightning.overrides.distributed import IndexBatchSamplerWrapper, UnrepeatedDistributedSampler\nfrom pytorch_lightning.trainer.connectors.accelerator_connector import AcceleratorConnector\nfrom pytorch_lightning.trainer.states import RunningStage\nfrom pytorch_lightning.trainer.supporters import CombinedLoader\nfrom pytorch_lightning.utilities import rank_zero_warn\nfrom pytorch_lightning.utilities.apply_func import apply_to_collection\nfrom pytorch_lightning.utilities.auto_restart import (\n _capture_metadata_collate,\n CaptureIterableDataset,\n CaptureMapDataset,\n FastForwardSampler,\n)\nfrom pytorch_lightning.utilities.data import has_iterable_dataset, has_len\nfrom pytorch_lightning.utilities.exceptions import MisconfigurationException\nfrom pytorch_lightning.utilities.imports import _fault_tolerant_training\nfrom pytorch_lightning.utilities.model_helpers import is_overridden\nfrom pytorch_lightning.utilities.seed import pl_worker_init_function\n\n\nclass TrainerDataLoadingMixin(ABC):\n\n # this is just a summary on variables used in this abstract class,\n # the proper values/initialisation should be done in child class\n val_check_interval: float\n tpu_local_core_rank: int\n train_dataloader: DataLoader\n num_training_batches: Union[int, float]\n val_check_batch: float\n val_dataloaders: Optional[List[DataLoader]]\n num_val_batches: List[Union[int, float]]\n test_dataloaders: Optional[List[DataLoader]]\n num_test_batches: List[Union[int, float]]\n limit_train_batches: Union[int, float]\n log_every_n_steps: int\n overfit_batches: Union[int, float]\n distributed_sampler_kwargs: dict\n accelerator: Accelerator\n accelerator_connector: AcceleratorConnector\n call_hook: Callable\n\n def _worker_check(self, dataloader: DataLoader, name: str) -> None:\n if not isinstance(dataloader, DataLoader):\n return\n\n using_spawn = self.accelerator_connector.distributed_backend == \"ddp_spawn\"\n num_cpus = multiprocessing.cpu_count()\n\n # ddp_spawn + num_workers > 0 don't mix! tell the user\n if dataloader.num_workers > 0 and using_spawn:\n # checks for the attr persistent_workers available in pytorch >= 1.7\n if hasattr(dataloader, \"persistent_workers\"):\n if not dataloader.persistent_workers:\n rank_zero_warn(\n \"num_workers>0, persistent_workers=False, and accelerator=ddp_spawn\"\n \" may result in data loading bottlenecks.\"\n \" Consider setting persistent_workers=True\"\n \" (this is a limitation of Python .spawn() and PyTorch)\"\n )\n else:\n rank_zero_warn(\n \"num_workers>0 and accelerator=ddp_spawn do not mix well\"\n \" and may result in data loading bottlenecks.\"\n \" Consider setting accelerator=ddp to use num_workers>0\"\n \" (this is a limitation of Python .spawn() and PyTorch)\"\n )\n\n elif dataloader.num_workers == 0 and using_spawn:\n # checks for the attr persistent_workers available in pytorch >= 1.7\n if hasattr(dataloader, \"persistent_workers\"):\n if not dataloader.persistent_workers:\n rank_zero_warn(\n \"accelerator=ddp_spawn and num_workers=0 may result in data loading bottlenecks.\"\n \" Consider setting num_workers>0 and persistent_workers=True\"\n )\n else:\n rank_zero_warn(\n \"accelerator=ddp_spawn and num_workers=0 may result in data loading bottlenecks.\"\n \" Consider setting accelerator=ddp and set num_workers>0\"\n )\n\n elif dataloader.num_workers <= 2 < num_cpus and not using_spawn:\n rank_zero_warn(\n f\"The dataloader, {name}, does not have many workers which may be a bottleneck.\"\n \" Consider increasing the value of the `num_workers` argument`\"\n f\" (try {num_cpus} which is the number of cpus on this machine)\"\n \" in the `DataLoader` init to improve performance.\"\n )\n\n def auto_add_worker_init_fn(self, dataloader: DataLoader) -> None:\n if int(os.environ.get(\"PL_SEED_WORKERS\", 0)) and dataloader.worker_init_fn is None:\n dataloader.worker_init_fn = partial(pl_worker_init_function, rank=self.global_rank)\n\n def auto_add_sampler(self, dataloader: Any, shuffle: bool, mode: Optional[RunningStage] = None) -> Any:\n if isinstance(dataloader, CombinedLoader):\n # apply `auto_add_sampler` on all the collection of loaders\n dataloader.loaders = apply_to_collection(\n dataloader.loaders, DataLoader, self.auto_add_sampler, shuffle, mode=mode\n )\n return dataloader\n\n # don't do anything if it's not a dataloader\n if not isinstance(dataloader, DataLoader):\n return dataloader\n\n if (\n self.accelerator_connector.replace_sampler_ddp\n and self.accelerator_connector.is_distributed\n and not isinstance(dataloader.sampler, DistributedSampler)\n and not has_iterable_dataset(dataloader)\n ):\n if not isinstance(dataloader.sampler, (SequentialSampler, RandomSampler)):\n raise MisconfigurationException(\n \"You seem to have configured a sampler in your DataLoader. This will be replaced \"\n \" by `DistributedSampler` since `replace_sampler_ddp` is True and you are using\"\n \" distributed training. Either remove the sampler from your DataLoader or set\"\n \" `replace_sampler_ddp`=False if you want to use your custom sampler.\"\n )\n sampler = self._get_distributed_sampler(dataloader, shuffle, mode=mode)\n dataloader = self.replace_sampler(dataloader, sampler, mode=mode)\n else:\n # use current sampler\n sampler = dataloader.sampler\n\n return dataloader\n\n @staticmethod\n def _resolve_batch_sampler(\n dataloader: DataLoader, sampler: Optional[Sampler], mode: Optional[RunningStage] = None\n ) -> Dict[str, Any]:\n batch_sampler = getattr(dataloader, \"batch_sampler\")\n is_predicting = mode == RunningStage.PREDICTING\n # checking the batch sampler type is different than PyTorch default.\n if (batch_sampler is not None and type(batch_sampler) is not BatchSampler) or is_predicting:\n batch_sampler = type(batch_sampler)(\n sampler,\n batch_size=batch_sampler.batch_size,\n drop_last=(False if is_predicting else batch_sampler.drop_last),\n )\n if is_predicting:\n batch_sampler = IndexBatchSamplerWrapper(batch_sampler)\n\n if _fault_tolerant_training():\n fast_forward_sampler = batch_sampler = FastForwardSampler(batch_sampler)\n fast_forward_sampler.setup(dataloader_batch_size=1)\n\n return {\n \"sampler\": None,\n \"shuffle\": False,\n \"batch_sampler\": batch_sampler,\n \"batch_size\": 1,\n \"drop_last\": False,\n }\n\n if _fault_tolerant_training():\n fast_forward_sampler = sampler = FastForwardSampler(sampler)\n fast_forward_sampler.setup(dataloader_batch_size=dataloader.batch_size)\n\n return {\"sampler\": sampler, \"shuffle\": False, \"batch_sampler\": None}\n\n @staticmethod\n def _get_dataloader_init_kwargs(\n dataloader: DataLoader, sampler: Optional[Sampler], mode: Optional[RunningStage] = None\n ) -> Dict[str, Any]:\n if not isinstance(dataloader, DataLoader):\n raise ValueError(f\"The dataloader {dataloader} needs to subclass `torch.utils.data.DataLoader`\")\n\n # get the dataloader instance attributes\n attrs = {k: v for k, v in vars(dataloader).items() if not k.startswith(\"_\")}\n # not part of `vars`\n attrs[\"multiprocessing_context\"] = dataloader.multiprocessing_context\n\n # get the dataloader instance `__init__` parameters\n params = dict(inspect.signature(dataloader.__init__).parameters)\n has_variadic_kwargs = any(p.kind is p.VAR_KEYWORD for p in params.values())\n if has_variadic_kwargs:\n # if the signature takes kwargs, assume they will be passed down with `super().__init__(kwargs)`\n params.update(inspect.signature(DataLoader.__init__).parameters)\n del params[\"self\"]\n\n # keep only the params whose default is different to the current attr value\n non_defaults = {name for name, p in params.items() if name in attrs and p.default != attrs[name]}\n # add `dataset` as it might have been replaced with `args`\n non_defaults.add(\"dataset\")\n\n # kwargs to re-construct the dataloader\n dl_kwargs = {k: v for k, v in attrs.items() if k in non_defaults}\n dl_kwargs.update(TrainerDataLoadingMixin._resolve_batch_sampler(dataloader, sampler, mode=mode))\n\n required_args = {\n p.name\n for p in params.values()\n if p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD)\n and p.default is p.empty\n and p.name not in dl_kwargs\n }\n # the dataloader has required args which we could not extract from the existing attributes\n if required_args:\n required_args = sorted(required_args)\n dataloader_cls_name = dataloader.__class__.__name__\n raise MisconfigurationException(\n f\"Trying to inject `DistributedSampler` into the `{dataloader_cls_name}` instance. \"\n \"This would fail as some of the `__init__` arguments are not available as instance attributes. \"\n f\"The missing attributes are {required_args}. \"\n f\"HINT: If you wrote the `{dataloader_cls_name}` class, define `self.missing_arg_name` or \"\n \"manually add the `DistributedSampler` as: \"\n f\"`{dataloader_cls_name}(dataset, sampler=DistributedSampler(dataset))`.\"\n )\n\n if not has_variadic_kwargs:\n # the dataloader signature does not allow keyword arguments that need to be passed\n missing_kwargs = dl_kwargs.keys() - params.keys()\n if missing_kwargs:\n missing_kwargs = sorted(missing_kwargs)\n dataloader_cls_name = dataloader.__class__.__name__\n raise MisconfigurationException(\n f\"Trying to inject `DistributedSampler` into the `{dataloader_cls_name}` instance. \"\n \"This would fail as it doesn't expose all its attributes in the `__init__` signature. \"\n f\"The missing arguments are {missing_kwargs}. \"\n f\"HINT: If you wrote the `{dataloader_cls_name}` class, add the `__init__` arguments or \"\n \"manually add the `DistributedSampler` as: \"\n f\"`{dataloader_cls_name}(dataset, sampler=DistributedSampler(dataset))`.\"\n )\n\n if isinstance(dl_kwargs[\"dataset\"], IterableDataset):\n dl_kwargs[\"batch_sampler\"] = None\n dl_kwargs[\"sampler\"] = None\n\n if _fault_tolerant_training():\n if isinstance(dl_kwargs[\"dataset\"], IterableDataset):\n # wrap the `IterableDataset` into a `CaptureIterableDataset` to record sampler states.\n dl_kwargs[\"dataset\"] = CaptureIterableDataset(dataset=dl_kwargs[\"dataset\"])\n elif len(dl_kwargs[\"dataset\"]):\n dl_kwargs[\"dataset\"] = CaptureMapDataset(dataset=dl_kwargs[\"dataset\"])\n else:\n raise MisconfigurationException(\n \"This shouldn't happen, please open an issue on Lightning Github repository.\"\n )\n\n return dl_kwargs\n\n @staticmethod\n def replace_sampler(dataloader: DataLoader, sampler, mode: Optional[RunningStage] = None) -> DataLoader:\n dl_kwargs = TrainerDataLoadingMixin._get_dataloader_init_kwargs(dataloader, sampler, mode=mode)\n dl_cls = type(dataloader)\n dataloader = dl_cls(dl_kwargs)\n return dataloader\n\n def _get_distributed_sampler(\n self, dataloader: DataLoader, shuffle: bool, mode: Optional[RunningStage] = None\n ) -> DistributedSampler:\n kwargs = self.distributed_sampler_kwargs\n kwargs[\"shuffle\"] = shuffle and not self.overfit_batches\n kwargs.setdefault(\"seed\", int(os.getenv(\"PL_GLOBAL_SEED\", 0)))\n cls = UnrepeatedDistributedSampler if mode == RunningStage.PREDICTING else DistributedSampler\n sampler = cls(dataloader.dataset, kwargs)\n return sampler\n\n def reset_train_dataloader(self, model: Optional[\"pl.LightningModule\"] = None) -> None:\n \"\"\"Resets the train dataloader and initialises required variables (number of batches, when to validate,\n etc.).\n\n Args:\n model: The `LightningModule` if calling this outside of the trainer scope.\n \"\"\"\n self.train_dataloader = self.request_dataloader(RunningStage.TRAINING, model=model)\n\n if self.overfit_batches > 0:\n if hasattr(self.train_dataloader, \"sampler\") and isinstance(self.train_dataloader.sampler, RandomSampler):\n rank_zero_warn(\n \"You requested to overfit but enabled training dataloader shuffling.\"\n \" We are turning off the training dataloader shuffling for you.\"\n )\n self.train_dataloader = self.replace_sampler(\n self.train_dataloader, SequentialSampler(self.train_dataloader.dataset), mode=RunningStage.TRAINING\n )\n\n # automatically add samplers\n self.train_dataloader = apply_to_collection(\n self.train_dataloader, DataLoader, self.auto_add_sampler, shuffle=True, mode=RunningStage.TRAINING\n )\n\n # check the workers recursively\n apply_to_collection(self.train_dataloader, DataLoader, self._worker_check, \"train_dataloader\")\n\n # add worker_init_fn for correct seeding in worker processes\n apply_to_collection(self.train_dataloader, DataLoader, self.auto_add_worker_init_fn)\n\n # add collate_fn to collect metadata for fault tolerant training\n if _fault_tolerant_training():\n apply_to_collection(self.train_dataloader, DataLoader, self._add_sampler_metadata_collate)\n\n # wrap the sequence of train loaders to a CombinedLoader object for computing the num_training_batches\n self.train_dataloader = CombinedLoader(self.train_dataloader, self.data_connector.multiple_trainloader_mode)\n\n self.num_training_batches = len(self.train_dataloader) if has_len(self.train_dataloader) else float(\"inf\")\n\n if isinstance(self.limit_train_batches, int) or self.limit_train_batches == 0.0:\n self.num_training_batches = min(self.num_training_batches, int(self.limit_train_batches))\n elif self.num_training_batches != float(\"inf\"):\n self.num_training_batches = int(self.num_training_batches self.limit_train_batches)\n elif self.limit_train_batches != 1.0:\n raise MisconfigurationException(\n \"When using an IterableDataset for `limit_train_batches`,\"\n \" `Trainer(limit_train_batches)` must be `0.0`, `1.0` or an int. An int k specifies\"\n \" `num_training_batches` to use.\"\n )\n\n # determine when to check validation\n # if int passed in, val checks that often\n # otherwise, it checks in [0, 1.0] % range of a training epoch\n if isinstance(self.val_check_interval, int):\n self.val_check_batch = self.val_check_interval\n if self.val_check_batch > self.num_training_batches:\n raise ValueError(\n f\"`val_check_interval` ({self.val_check_interval}) must be less than or equal \"\n f\"to the number of the training batches ({self.num_training_batches}). \"\n \"If you want to disable validation set `limit_val_batches` to 0.0 instead.\"\n )\n else:\n if not has_len(self.train_dataloader):\n if self.val_check_interval == 1.0:\n self.val_check_batch = float(\"inf\")\n else:\n raise MisconfigurationException(\n \"When using an IterableDataset for `train_dataloader`,\"\n \" `Trainer(val_check_interval)` must be `1.0` or an int. An int k specifies\"\n \" checking validation every k training batches.\"\n )\n else:\n self.val_check_batch = int(self.num_training_batches * self.val_check_interval)\n self.val_check_batch = max(1, self.val_check_batch)\n\n if self.logger and self.num_training_batches < self.log_every_n_steps:\n rank_zero_warn(\n f\"The number of training samples ({self.num_training_batches}) is smaller than the logging interval\"\n f\" Trainer(log_every_n_steps={self.log_every_n_steps}). Set a lower value for log_every_n_steps if\"\n \" you want to see logs for the training epoch.\"\n )\n\n def _reset_eval_dataloader(\n self, mode: RunningStage, model: Optional[\"pl.LightningModule\"] = None\n ) -> Tuple[List[Union[int, float]], List[DataLoader]]:\n \"\"\"Generic method to reset a dataloader for evaluation.\n\n Args:\n mode: The running stage of the ``Trainer``\n model: The ``LightningModule`` if calling this outside of the trainer scope.\n\n Returns:\n Tuple (num_batches, dataloaders)\n \"\"\"\n assert mode.evaluating or mode == RunningStage.PREDICTING\n\n # always get the loaders first so we can count how many there are\n dataloaders = self.request_dataloader(mode, model=model)\n\n if not isinstance(dataloaders, list):\n dataloaders = [dataloaders]\n\n # when overfitting, use the training loader as val and test\n # duplicate it the numb of times needed to match the train loaders\n if self.overfit_batches > 0:\n train_dataloader = self.request_dataloader(RunningStage.TRAINING, model=model)\n dataloaders = [deepcopy(train_dataloader) for _ in range(len(dataloaders))]\n\n for loader_i in range(len(dataloaders)):\n loader = dataloaders[loader_i]\n\n if hasattr(loader, \"sampler\") and isinstance(loader.sampler, RandomSampler):\n\n # when overfitting, the dataloader should not have sampler\n if self.overfit_batches > 0 and mode.evaluating:\n rank_zero_warn(\n \"You requested to overfit but enabled val/test dataloader shuffling.\"\n \" We are turning it off for you.\"\n )\n dataloaders[loader_i] = self.replace_sampler(loader, SequentialSampler(loader.dataset), mode=mode)\n else:\n rank_zero_warn(\n f\"Your `{mode.dataloader_prefix}_dataloader` has `shuffle=True`,\"\n \"it is strongly recommended that you turn this off for val/test/predict dataloaders.\"\n )\n\n if any(dl is None for dl in dataloaders):\n rank_zero_warn(\"One of given dataloaders is None and it will be skipped.\")\n\n # add samplers\n dataloaders = [self.auto_add_sampler(dl, False, mode=mode) for dl in dataloaders if dl is not None]\n\n # add worker_init_fn for correct seeding in worker processes\n apply_to_collection(dataloaders, dtype=DataLoader, function=self.auto_add_worker_init_fn)\n\n loader_num_batches = []\n\n # determine number of batches\n # datasets could be none, 1 or 2+\n if len(dataloaders) != 0:\n for i, dataloader in enumerate(dataloaders):\n num_batches = len(dataloader) if has_len(dataloader) else float(\"inf\")\n self._worker_check(dataloader, f\"{mode.dataloader_prefix}_dataloader {i}\")\n\n # percent or num_steps\n limit_eval_batches = getattr(self, f\"limit_{mode.dataloader_prefix}_batches\")\n\n # limit num batches either as a percent or num steps\n if isinstance(limit_eval_batches, int) or limit_eval_batches == 0.0:\n num_batches = min(num_batches, int(limit_eval_batches))\n elif num_batches != float(\"inf\"):\n num_batches = int(num_batches * limit_eval_batches)\n elif limit_eval_batches != 1.0:\n raise MisconfigurationException(\n f\"When using an IterableDataset for `limit_{mode}_batches`,\"\n f\" `Trainer(limit_{mode.dataloader_prefix}_batches)` must be `0.0`, `1.0` or an int. An int k\"\n f\" specifies `num_{mode.dataloader_prefix}_batches` to use.\"\n )\n\n if num_batches == 0 and limit_eval_batches > 0.0 and isinstance(limit_eval_batches, float):\n min_pct = 1.0 / len(dataloader)\n raise MisconfigurationException(\n f\"you requested to check {limit_eval_batches} of the `{mode.dataloader_prefix}_dataloader` but\"\n f\" {limit_eval_batches}*{num_batches} < 1. Please increase the\"\n f\" `limit_{mode.dataloader_prefix}_batches` flag. Try at least\"\n f\" `limit_{mode.dataloader_prefix}_batches={min_pct}`\"\n )\n\n loader_num_batches.append(num_batches)\n\n return loader_num_batches, dataloaders\n\n def reset_val_dataloader(self, model: Optional[\"pl.LightningModule\"] = None) -> None:\n \"\"\"Resets the validation dataloader and determines the number of batches.\n\n Args:\n model: The `LightningModule` if called outside of the trainer scope.\n \"\"\"\n pl_module = self.lightning_module or model\n has_loader = is_overridden(\"val_dataloader\", pl_module)\n has_step = is_overridden(\"validation_step\", pl_module)\n if has_loader and has_step:\n self.num_val_batches, self.val_dataloaders = self._reset_eval_dataloader(\n RunningStage.VALIDATING, model=pl_module\n )\n\n def reset_test_dataloader(self, model: Optional[\"pl.LightningModule\"] = None) -> None:\n \"\"\"Resets the test dataloader and determines the number of batches.\n\n Args:\n model: The `LightningModule` if called outside of the trainer scope.\n \"\"\"\n pl_module = self.lightning_module or model\n has_loader = is_overridden(\"test_dataloader\", pl_module)\n has_step = is_overridden(\"test_step\", pl_module)\n if has_loader and has_step:\n self.num_test_batches, self.test_dataloaders = self._reset_eval_dataloader(\n RunningStage.TESTING, model=pl_module\n )\n\n def reset_predict_dataloader(self, model: Optional[\"pl.LightningModule\"] = None) -> None:\n \"\"\"Resets the predict dataloader and determines the number of batches.\n\n Args:\n model: The `LightningModule` if called outside of the trainer scope.\n \"\"\"\n pl_module = self.lightning_module or model\n has_loader = is_overridden(\"predict_dataloader\", pl_module)\n if has_loader:\n self.num_predict_batches, self.predict_dataloaders = self._reset_eval_dataloader(\n RunningStage.PREDICTING, model=pl_module\n )\n\n def reset_train_val_dataloaders(self, model: Optional[\"pl.LightningModule\"] = None) -> None:\n \"\"\"Resets train and val dataloaders if none are attached to the trainer.\n\n The val dataloader must be initialized before training loop starts, as the training loop\n inspects the val dataloader to determine whether to run the evaluation loop.\n\n Args:\n model: The `LightningModule` if called outside of the trainer scope.\n \"\"\"\n if self.train_dataloader is None:\n self.reset_train_dataloader(model=model)\n if self.val_dataloaders is None:\n self.reset_val_dataloader(model=model)\n\n def request_dataloader(\n self, stage: RunningStage, model: Optional[\"pl.LightningModule\"] = None\n ) -> Union[DataLoader, List[DataLoader]]:\n \"\"\"Handles downloading data in the GPU or TPU case.\n\n Returns:\n The dataloader\n \"\"\"\n hook = f\"{stage.dataloader_prefix}_dataloader\"\n self.call_hook(\"on_\" + hook, pl_module=model)\n dataloader = self.call_hook(hook, pl_module=model)\n if isinstance(dataloader, tuple):\n dataloader = list(dataloader)\n self.training_type_plugin.barrier(\"get_dataloaders\")\n return dataloader\n\n @staticmethod\n def _add_sampler_metadata_collate(dataloader: DataLoader) -> None:\n \"\"\"Wrap default collate function to retrive ``FastForwardSampler`` state dict when fault tolerant is\n enabled.\"\"\"\n dataloader.collate_fn = partial(\n _capture_metadata_collate, dataset=dataloader.dataset, default_collate=dataloader.collate_fn\n )\n" ]	[ [ "torch.utils.data.SequentialSampler" ] ]
egreen-park/crwusiz	[ "da528ebea9945f5a2a0a286467bb1c349aa7472f" ]	[ "selfdrive/controls/lib/lane_planner.py" ]	[ "from common.numpy_fast import interp\nimport numpy as np\nfrom selfdrive.hardware import EON, TICI\nfrom cereal import log\n\n\nTRAJECTORY_SIZE = 33\n# camera offset is meters from center car to camera\nif EON:\n CAMERA_OFFSET = 0.10\n PATH_OFFSET = 0.0\nelif TICI:\n CAMERA_OFFSET = -0.04\n PATH_OFFSET = -0.04\nelse:\n CAMERA_OFFSET = 0.0\n PATH_OFFSET = 0.0\n\n\nclass LanePlanner:\n def __init__(self, wide_camera=False):\n self.ll_t = np.zeros((TRAJECTORY_SIZE,))\n self.ll_x = np.zeros((TRAJECTORY_SIZE,))\n self.lll_y = np.zeros((TRAJECTORY_SIZE,))\n self.rll_y = np.zeros((TRAJECTORY_SIZE,))\n self.lane_width_estimate = 3.7\n self.lane_width_certainty = 1.0\n self.lane_width = 3.7\n\n self.lll_prob = 0.\n self.rll_prob = 0.\n self.d_prob = 0.\n\n self.lll_std = 0.\n self.rll_std = 0.\n\n self.l_lane_change_prob = 0.\n self.r_lane_change_prob = 0.\n\n self.camera_offset = -CAMERA_OFFSET if wide_camera else CAMERA_OFFSET\n self.path_offset = -PATH_OFFSET if wide_camera else PATH_OFFSET\n\n def parse_model(self, md):\n if len(md.laneLines) == 4 and len(md.laneLines[0].t) == TRAJECTORY_SIZE:\n self.ll_t = (np.array(md.laneLines[1].t) + np.array(md.laneLines[2].t))/2\n # left and right ll x is the same\n self.ll_x = md.laneLines[1].x\n # only offset left and right lane lines; offsetting path does not make sense\n self.lll_y = np.array(md.laneLines[1].y) - self.camera_offset\n self.rll_y = np.array(md.laneLines[2].y) - self.camera_offset\n self.lll_prob = md.laneLineProbs[1]\n self.rll_prob = md.laneLineProbs[2]\n self.lll_std = md.laneLineStds[1]\n self.rll_std = md.laneLineStds[2]\n\n if len(md.meta.desireState):\n self.l_lane_change_prob = md.meta.desireState[log.LateralPlan.Desire.laneChangeLeft]\n self.r_lane_change_prob = md.meta.desireState[log.LateralPlan.Desire.laneChangeRight]\n\n def get_d_path(self, v_ego, path_t, path_xyz):\n # Reduce reliance on lanelines that are too far apart or\n # will be in a few seconds\n path_xyz[:, 1] -= self.path_offset\n l_prob, r_prob = self.lll_prob, self.rll_prob\n width_pts = self.rll_y - self.lll_y\n prob_mods = []\n for t_check in [0.0, 1.5, 3.0]:\n width_at_t = interp(t_check * (v_ego + 7), self.ll_x, width_pts)\n prob_mods.append(interp(width_at_t, [4.0, 5.0], [1.0, 0.0]))\n mod = min(prob_mods)\n l_prob = mod\n r_prob = mod\n\n # Reduce reliance on uncertain lanelines\n l_std_mod = interp(self.lll_std, [.15, .3], [1.0, 0.0])\n r_std_mod = interp(self.rll_std, [.15, .3], [1.0, 0.0])\n l_prob = l_std_mod\n r_prob = r_std_mod\n\n # Find current lanewidth\n self.lane_width_certainty += 0.05 * (l_prob * r_prob - self.lane_width_certainty)\n current_lane_width = abs(self.rll_y[0] - self.lll_y[0])\n self.lane_width_estimate += 0.005 * (current_lane_width - self.lane_width_estimate)\n speed_lane_width = interp(v_ego, [0., 31.], [2.8, 3.5])\n self.lane_width = self.lane_width_certainty * self.lane_width_estimate + \\\n (1 - self.lane_width_certainty) * speed_lane_width\n\n clipped_lane_width = min(4.0, self.lane_width)\n path_from_left_lane = self.lll_y + clipped_lane_width / 2.0\n path_from_right_lane = self.rll_y - clipped_lane_width / 2.0\n\n self.d_prob = l_prob + r_prob - l_prob * r_prob\n lane_path_y = (l_prob * path_from_left_lane + r_prob * path_from_right_lane) / (l_prob + r_prob + 0.0001)\n lane_path_y_interp = np.interp(path_t, self.ll_t, lane_path_y)\n path_xyz[:,1] = self.d_prob * lane_path_y_interp + (1.0 - self.d_prob) * path_xyz[:,1]\n return path_xyz\n" ]	[ [ "numpy.array", "numpy.zeros", "numpy.interp" ] ]
cattech-lab/cantera_examples	[ "13e969b2a767bed5bb0d79adf86187cd9fbd090d" ]	[ "ic_engine.py" ]	[ "\"\"\"\nSimulation of a internal combustion engine.\n\"\"\"\n\nimport cantera as ct\nimport numpy as np\nimport csv\n\n#------------------------------------------------------\n# Input Parameters\nrpm = 600.0 # engine speed [rpm]\nbore = 82.55 # bore diameter [mm]\nstroke = 114.3 # stroke [mm]\ncratio = 10.0 # compression ratio [-]\nconrod = 200.0 # connecting rod [mm]\n\n# initial temperature, pressure, and equivalence ratio\nT_ini = 350.0 # [K]\np_ini = 1.0e5 # [Pa]\nphi = 0.33\n\n# outer temperature, pressure, and composition\nT_out = 300.0 # [K]\np_out = 1.0e5 # [Pa]\nc_out = 'O2:1.0, N2:3.76'\n\n# Reaction mechanism name\nreaction_mechanism = 'reduced_247.cti'\n\n# Simulation time\nca_start = -144.0 # start CA [deg]\nca_end = 180.0 # end CA [deg]\nca_step = 0.01 # step CA [deg]\nca_out = 0.2 # output CA [deg]\n\n#------------------------------------------------------\n# load reaction mechanism\ngas = ct.Solution(reaction_mechanism)\n\n# define initial state\ngas.TP = T_ini, p_ini\ngas.set_equivalence_ratio(phi, 'NC7H16', 'O2:1.0, N2:3.76')\nr = ct.IdealGasReactor(gas)\nsim = ct.ReactorNet([r])\ngas.TPX = T_out, p_out, c_out\nouter = ct.Reservoir(gas)\n\n# convert time to crank angle [rad]\nrps = rpm / 60.0\ndef crank_angle(t):\n return 2.0 * np.pi * rps * t + ca_start * np.pi / 180.0\n\n# set up IC engine parameters\nstroke = 0.001\nbore = 0.001\nconrod = 0.001\narea = 0.25 np.pi * bore * bore\nvol_h = stroke * area # volume cylinder\nvol_c = vol_h / (cratio - 1.0) # volume combustion dome\nca = crank_angle(0.0) # initial CA\nr_ca = stroke * 0.5 # crank radius\nvol_ini= (r_ca + conrod - (r_ca * np.cos(ca) + np.sqrt(conrod2 - r_ca2 * np.sin(ca)*2))) area + vol_c\nr.volume = vol_ini # initial volume\n\n# set up piston \npiston = ct.Wall(outer, r)\npiston.area = area # piston area\ndef piston_speed(t):\n ca = crank_angle(t)\n return -2.0 * np.pi * rps * (r_ca * np.sin(ca) + r_ca*2 np.sin(2.0 * ca) / 2.0 / np.sqrt(conrod2 - r_ca2 * np.sin(ca)*2))\npiston.set_velocity(piston_speed) # piston speed\n\n# set up time\nt_sim = (ca_end - ca_start) / rps / 360.0 # simulation time\nt_step = ca_step / rps / 360.0 # simulation time step\nt_out = ca_out / rps / 360.0 # simulation output time\nttt = 0.0\n\n# set up output data arrays\nstates = ct.SolutionArray(r.thermo)\nt = []\nheat_release_rate = []\n\n# output file\noutfile = open('ic_engine.csv', 'w', newline=\"\")\ncsvfile = csv.writer(outfile)\ncsvfile.writerow(['ca[deg]','P[bar]','T[K]','HR[J/deg]'])\n\n# do simulation\nfor t_i in np.arange(0, t_sim, t_step):\n sim.advance(t_i)\n\n # write output data\n if t_i >= ttt:\n ca = crank_angle(t_i) 180.0 / np.pi\n t.append(ca)\n\n states.append(r.thermo.state)\n\n hr = -r.volume * ct.gas_constant * r.T * np.sum(gas.standard_enthalpies_RT * r.thermo.net_production_rates, 0)\n hr = hr * t_step / ca_step\n heat_release_rate.append(hr)\n\n csvfile.writerow([ca, r.thermo.P / 1.0e5, r.T, hr])\n ttt += t_out\n\noutfile.close()\n\n#------------------------------------------------------\n# Plot Results in matplotlib\nimport matplotlib.pyplot as plt\n\n# pressure\nfig1 = plt.figure()\nax1 = fig1.add_subplot()\nax1.plot(t, states.P / 1.0e5)\nax1.set_ylabel('P [bar]')\nax1.set_xlabel('CA [deg]')\nax1.set_xlim(-60, 60)\n\n# temperature\nfig2 = plt.figure()\nax2 = fig2.add_subplot()\nax2.plot(t, states.T)\nax2.set_ylabel('T [K]')\nax2.set_xlabel('CA [deg]')\nax2.set_xlim(-60, 60)\n\n# heat release rate\nfig3 = plt.figure()\nax3 = fig3.add_subplot()\nax3.plot(t, heat_release_rate)\nax3.set_ylabel('Heat release rate [J/deg]')\nax3.set_xlabel('CA [deg]')\nax3.set_xlim(-60, 60)\n\nplt.show()\n" ]	[ [ "numpy.arange", "numpy.cos", "numpy.sin", "matplotlib.pyplot.show", "numpy.sum", "matplotlib.pyplot.figure" ] ]
deKeijzer/SRON-DCGAN	[ "1ead827ebf549917435e6bc9ddd2d4d5951aa205" ]	[ "notebooks/model_v2_small.py" ]	[ "# General imports\nfrom __future__ import print_function\n#%matplotlib inline\nimport argparse\nimport os\nimport random\nimport torch\nimport torch.nn as nn\nimport torch.nn.parallel\nimport torch.backends.cudnn as cudnn\nimport torch.optim as optim\nimport torch.utils.data\nimport torchvision.datasets as dset\nimport torchvision.transforms as transforms\nimport torchvision.utils as vutils\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport matplotlib.animation as animation\nfrom IPython.display import HTML\n\nfrom keijzer_exogan import \n\n\nclass Generator(nn.Module):\n def __init__(self, ngpu, nz=100, ngf=32, nc=1):\n super(Generator, self).__init__()\n self.ngpu = ngpu\n self.nz = nz\n self.nc = nc\n self.ngf = ngf\n \n \"\"\"\n where (in_channels, out_channels, \n kernel_size, stride=1, padding=0, output_padding=0, groups=1, bias=True, dilation=1)\n \"\"\"\n self.main = nn.Sequential(\n \n #1\n # input is Z (100,1,1), going into a convolution\n nn.ConvTranspose2d( nz, ngf 16, 4, 1, 0, bias=False),\n nn.LeakyReLU(0.2, inplace=True), # Should use ReLU in generator according to DCGAN paper,\n #nn.Dropout2d(0.5),\n \n #2\n # state size. (ngf8) x 4 x 4\n nn.ConvTranspose2d(ngf 16, ngf * 8, 4, 2, 1, bias=False),\n nn.LeakyReLU(0.2, inplace=True),\n #nn.Dropout2d(0.5),\n \n #3\n # state size. (ngf4) x 8 x 8\n nn.ConvTranspose2d( ngf 8, ngf * 4, 4, 2, 1, bias=False),\n nn.LeakyReLU(0.2, inplace=True),\n #nn.Dropout2d(0.5),\n \n # G(z)\n nn.ConvTranspose2d( ngf * 4, nc, 4, 2, 1, bias=False),\n nn.Tanh() # Not used because ASPAs \n )\n\n def forward(self, input):\n return self.main(input)\n\n \nclass Discriminator(nn.Module):\n def __init__(self, ngpu, nc=1, ndf=32):\n super(Discriminator, self).__init__()\n self.ngpu = ngpu\n self.nc = nc\n self.ndf = ndf\n self.main = nn.Sequential(\n # input is (nc) x 64 x 64\n nn.Conv2d(nc, ndf4, 4, 2, 1, bias=False),\n nn.LeakyReLU(0.2, inplace=True),\n #nn.Dropout2d(0.5),\n \n # state size. (ndf) x 32 x 32\n nn.Conv2d(ndf4, ndf * 8, 4, 2, 1, bias=False),\n nn.LeakyReLU(0.2, inplace=True),\n #nn.Dropout2d(0.5),\n \n # state size. (ndf2) x 16 x 16\n nn.Conv2d(ndf 8, ndf * 16, 4, 2, 1, bias=False),\n nn.LeakyReLU(0.2, inplace=True),\n #nn.Dropout2d(0.5),\n \n # state size. (ndf4) x 8 x 8\n nn.Conv2d(ndf 16, 1, 4, 2, 1, bias=False),\n\n nn.Sigmoid()\n )\n\n def forward(self, input):\n return self.main(input)\n\n\n" ]	[ [ "torch.nn.ConvTranspose2d", "torch.nn.Conv2d", "torch.nn.Sigmoid", "torch.nn.Tanh", "torch.nn.LeakyReLU" ] ]
rafalou38/mangafetch	[ "6bd313f9b9cfb2ea729e49d382a4085c9aaf094e" ]	[ "src/images.py" ]	[ "import PIL.Image\nimport numpy\nimport os\n\n\ndef tile(image_path):\n try:\n ratio = 1.4\n image = PIL.Image.open(image_path)\n image = numpy.array(image)\n height = image.shape[1] * ratio\n\n if image.shape[1] * 2 < image.shape[0]:\n # width = image.shape[0]\n images = []\n y = 0\n for i in range(0, int(image.shape[0]), int(height)):\n chunk = image[i : int(i + height)]\n p = (\n os.path.splitext(image_path)[0]\n + \" cut \"\n + str(y)\n + os.path.splitext(image_path)[1]\n )\n PIL.Image.fromarray(chunk).save(p)\n images.append(p)\n y += 1\n return images\n else:\n return [image_path]\n except:\n return [image_path]\n\n\n# tile(\"tmp\\\\images\\\\sweet-home\\\\0\\\\1.jpeg\")\n# for image in tile(\"tmp\\\\images\\\\one-piece\\\\680\\\\1.jpeg\"):\n# \t# image.show()\n# \t# input()\n# \tprint(image)\n" ]	[ [ "numpy.array" ] ]
caegomezji/FORDAT	[ "450dca5a9b0c059429421b773be3e7d54367fdcf" ]	[ "forecasting.py" ]	[ "# ARIMA example\nfrom statsmodels.tsa.arima.model import ARIMA\nimport numpy as np\nfrom statsmodels.tools.eval_measures import rmse\nimport pmdarima as pm\nfrom fbprophet import Prophet\nfrom time import time\nimport matplotlib.pyplot as plt\nimport pandas as pd\nimport math\n\ndef BIC(y_real, y_model):\n n = len(y_real)\n k = 2\n resid = y_real - y_model\n sse = sum(resid*2)\n BIC_value = k math.log(n) - 2 * math.log(sse)\n return BIC_value\n\ndef AIC(y_real, y_modelo):\n resid = y_real - y_modelo\n print(resid)\n sse = sum(resid*2)\n k = 1 # parameters\n AIC_value = 2k - 2math.log(sse)\n return AIC_value\n\ndef make_forecast(data, model='prophet'):\n\n data = data.interpolate()\n test_months = 6\n train, test = data[0:-test_months], data[-test_months:]\n history = [x for x in train]\n predictions = list()\n future_months = 18\n test_time = len(test)\n\n if model == 'prophet':\n predictions = forecast_prophet(train, future_months)\n elif model == 'autoarima':\n predictions = forecast_autoarima(train, future_months)\n\n return test, predictions\n\ndef forecast_autoarima(data, future_months=12):\n\n history = [x for x in data]\n\n model = pm.auto_arima(history, start_p=0, d=1, start_q=0,\n max_p=2, max_d=2, max_q=2, start_P=0,\n D=1, start_Q=0, max_P=2, max_D=2,\n max_Q=2, m=12, seasonal=True,\n error_action='warn', trace=True,\n supress_warnings=True, stepwise=True,\n random_state=20, n_fits=10)\n\n predictions = model.predict(future_months)\n \n return pd.Series(predictions)\n\ndef forecast_prophet(data, future_months=12):\n\n data_model = data.reset_index(name='FOBDOL')\n\n data_model.columns = ['ds', 'y' ] # prophet model just understando these names\n #print(data_model.shape)\n # HERE YOU SHOULD PUT YOUR MODEL\n print('start model')\n model = Prophet(interval_width=0.95, seasonality_mode='multiplicative')\n\n print('model defined')\n model.fit(data_model)\n print('model fitted')\n # future_months = 12 # this variable is a slider in the app\n future = model.make_future_dataframe(periods=future_months, freq='MS') # predict on months\n forecast = model.predict(future)\n predictions = forecast.yhat\n print('predicted')\n # in case you want to see its output\n # print(forecast.head(2))\n # print(predictions)\n return predictions[-future_months:].reset_index()['yhat']\n\ndef forcast_arima(data):\n # data[Sector ] == X\n data = data.interpolate()\n size = int(len(data) 0.80)\n train, test = data[0:size], data[size:len(data)]\n history = [x for x in train]\n predictions = list()\n future_months = 12\n test_time = len(test)\n for t in range(test_time + future_months ):\n model = ARIMA(history, order=(5, 1, 0))\n model_fit = model.fit()\n output = model_fit.forecast()\n yhat = output[0]\n predictions.append(yhat)\n if t < test_time:\n obs = test[t]\n history.append(obs)\n if t >= test_time:\n history.append(yhat)\n\n # evaluate forecasts\n # error = np.sqrt(rmse(test, predictions))\n #print('Test RMSE: %.3f' % error)\n # plot forecasts against actual outcomes\n # plt.plot(np.array(test))\n # plt.plot(predictions, color='red')\n # plt.show()\n\n return test, predictions " ]	[ [ "pandas.Series" ] ]
guglielmocola/RetweetCascade	[ "f96319d0107473715104acceb2ff0925d35dd9e3" ]	[ "retweetcascade/rt_cascade_friendships.py" ]	[ "import pandas as pd\nfrom retweetcascade.utility_functions import __convert_to_pandas_list_tw, __explode_dict\n\n\ndef rt_cascade_friendships(retweets, followers, friends, *kwargs):\n \"\"\"Estimate the retweet cascade based on friendship among retweeters.\n A retweeter X is linked to the root R (original tweet's author) if he/she is a follower\n of R, otherwise it is linked to the last friend who retweeted before X. If X is not\n a follower of R and there are no friends who retweeted before X, then it is not possible\n to automatically link X to another retweeter, and X is disconnected from the cascade graph.\n\n :param retweets: list of retweets, each retweet being a tweet object.\n :param followers: list of followers of the root (id_str values).\n :param friends: dictionary describing the friends of retweeters (only the friends of\n retweeters who are not followers of the root are useful); each key is the id_str\n of a retweeter and points to the list of friends (id_str values).\n\n :keyword verbose: Verbose mode (default False)\n :keyword qt: Weight assigned to quotes (default 1.0)\n :keyword re: Weight assigned to replies (default 1.0)\n :keyword rt: Weight assigned to retweets (default 1.0)\n\n :return: Returns a pandas DataFrame with columns source and target, where each\n row describes an edge of the retweet cascade graph. Disconnected nodes are included with a\n target equal to NaN.\n \"\"\"\n\n # Set keyword arguments, start from default values\n verbose = False\n if 'verbose' in kwargs:\n verbose = kwargs['verbose']\n\n # Find the root from a retweet.\n root_id = retweets[0]['retweeted_status']['user']['id_str']\n\n # DataFrame with RETWEETS (in case of multiple retweets from the same subject, keep the oldest)\n df_rt = __convert_to_pandas_list_tw(retweets, ['created_at', 'user.id_str'])\n df_rt = df_rt.sort_values(by=['created_at'], ascending=False)\n df_rt = df_rt.groupby(df_rt['user.id_str']).last().reset_index() # last is the oldest\n\n # List of retweeters who also are followers (\"direct retweeters\")\n direct_rt_list = []\n # List of non-follower retweeters (will be useful later to find disconnected nodes)\n nf_rt_list = []\n for rt in retweets:\n rt_user = rt['user']['id_str']\n if rt_user in followers:\n direct_rt_list.append(rt_user)\n else:\n nf_rt_list.append(rt_user)\n # Remove duplicates\n direct_rt_list = list(set(direct_rt_list))\n\n # Create DataFrame for these users, then add it to the main one.\n df_direct = pd.DataFrame(direct_rt_list, columns=['source'])\n df_direct['target'] = root_id\n\n # Create rt DataFrame with just non-follower retweeters.\n df_nf_rt = df_rt[~df_rt['user.id_str'].isin(direct_rt_list)].reset_index(drop=True)\n\n # Create DataFrame for friendships, with <user.id, friend.id> info\n df_friends = pd.DataFrame(__explode_dict(friends)).T\n df_friends.columns = ['follower_id_str', 'friend_id_str']\n\n # First merge links non-follower retweeters with their friends\n df_merge1 = df_nf_rt.merge(df_friends, left_on='user.id_str', right_on='follower_id_str')\n\n # Second merge adds retweet information for friends (this time the merge needs to be with\n # the entire retweets DataFrame)\n df_merge2 = df_merge1.merge(df_rt, left_on='friend_id_str', right_on='user.id_str', suffixes=('', '_y'))\n\n # Remove rows where 'created_at_y' > 'created_at'\n df_merge2['delta'] = (df_merge2['created_at'] - df_merge2['created_at_y']).dt.total_seconds()\n df_merge2 = df_merge2[df_merge2['delta'] > 0]\n\n df_final = df_merge2[['user.id_str', 'created_at', 'friend_id_str', 'created_at_y', 'delta']]\n df_final = df_final.sort_values(by=['delta'], ascending=False)\n df_final = df_final.groupby(df_final['user.id_str']).last().reset_index() # last is the oldest\n\n # Prepare cascade DataFrame based on friendship, then cat it with direct followers\n cascade_df = pd.DataFrame()\n cascade_df['source'] = df_final['user.id_str']\n cascade_df['target'] = df_final['friend_id_str']\n\n # Save list of \"friend-based\" non follower retweeters for later.\n fb_rt_list = cascade_df['source'].tolist()\n\n # Cat with direct retweeters (followers of root)\n cascade_df = pd.concat([cascade_df, df_direct], ignore_index=True)\n\n # Finally, find disconnected nodes, and add a row with NaN target for them.\n disconnected_nodes = set(nf_rt_list) - set(fb_rt_list)\n\n # print('dis:', len(disconnected_nodes), 'nf:', len(set(nf_rt_list)), 'fb-estimated', len(set(fb_rt_list)))\n\n # fw_in_int = set(fb_rt_list) - set(direct_rt_list)\n # print(len(fw_in_int))\n\n # Add disconnected nodes with 'NaN' target\n disconnected_df = pd.DataFrame(\n {'source': list(disconnected_nodes),\n 'target': [float(\"NaN\")] len(disconnected_nodes),\n })\n\n # Find final edges df, including disconnected nodes\n cascade_df = pd.concat([cascade_df, disconnected_df], ignore_index=True)\n\n # Remove the root from source, if present\n cascade_df.drop(cascade_df.loc[cascade_df['source'] == root_id].index, inplace=True)\n cascade_df.reset_index(inplace=True, drop=True)\n\n return cascade_df\n" ]	[ [ "pandas.concat", "pandas.DataFrame" ] ]
joshliu11/DSGN	[ "ac693e748ff3a7372b1292c2b7b3796854072030" ]	[ "dsgn/utils/torch_utils.py" ]	[ "import numpy as np\n\nimport torch\n\ndef project_image_to_rect(uv_depth, P):\n # uv_depth (3, N)\n\n c_u = P[0,2]\n c_v = P[1,2]\n f_u = P[0,0]\n f_v = P[1,1]\n b_x = P[0,3]/(-f_u) # relative \n b_y = P[1,3]/(-f_v)\n\n # use camera coordinate\n n = uv_depth.shape[1]\n x = ((uv_depth[0]-c_u)uv_depth[2])/f_u + b_x\n y = ((uv_depth[1]-c_v)uv_depth[2])/f_v + b_y\n return torch.stack([x, y, uv_depth[2]], dim=0)\n\ndef project_disp_to_depth_new(points_cam, Proj):\n xs, ys, disp = points_cam[0:1], points_cam[1:2], points_cam[2:3]\n _, h, w, d = disp.shape\n\n baseline = 0.54\n mask = disp > 0\n depth = Proj[0,0] * baseline / (disp + 1. - mask.float())\n points = torch.cat([xs, ys, depth], dim=0)\n points = points.reshape((3, -1))\n\n # camera coordinate\n cloud = project_image_to_rect(points, Proj)\n cloud = cloud.reshape(3, h, w, d)\n return cloud\n\ndef project_rect_to_image(pts_3d_rect, P):\n n = pts_3d_rect.shape[0]\n ones = torch.ones((n,1))\n if pts_3d_rect.is_cuda:\n ones = ones.cuda()\n pts_3d_rect = torch.cat([pts_3d_rect, ones], dim=1)\n pts_2d = torch.mm(pts_3d_rect, torch.transpose(P, 0, 1)) # nx3\n pts_2d[:,0] /= pts_2d[:,2]\n pts_2d[:,1] /= pts_2d[:,2]\n return pts_2d[:,0:2]\n\n# def compute_locations(h, w, stride, device):\n# shifts_x = torch.arange(\n# 0, w * stride, step=stride,\n# dtype=torch.float32, device=device\n# )\n# shifts_y = torch.arange(\n# 0, h * stride, step=stride,\n# dtype=torch.float32, device=device\n# )\n# shift_y, shift_x = torch.meshgrid(shifts_y, shifts_x)\n# shift_x = shift_x.reshape(-1)\n# shift_y = shift_y.reshape(-1)\n# locations = torch.stack((shift_x, shift_y), dim=1) + stride // 2\n# return locations\n\n# def compute_locations_3d(h, w, stride, device):\n# shifts_x = torch.arange(\n# 0, w * stride, step=stride,\n# dtype=torch.float32, device=device\n# )\n# shifts_y = torch.arange(\n# 0, h * stride, step=stride,\n# dtype=torch.float32, device=device\n# )\n# shift_y, shift_x = torch.meshgrid(shifts_y, shifts_x)\n# shift_x = shift_x.reshape(-1)\n# shift_y = shift_y.reshape(-1)\n# locations = torch.stack((shift_x, shift_y), dim=1) + stride // 2\n# return locations\n\ndef compute_locations_bev(Z_MIN, Z_MAX, VOXEL_Z_SIZE, X_MIN, X_MAX, VOXEL_X_SIZE, device):\n shifts_z = torch.arange(Z_MIN, Z_MAX - np.sign(VOXEL_Z_SIZE) * 1e-10, step=VOXEL_Z_SIZE, \n dtype=torch.float32).to(device) + VOXEL_Z_SIZE / 2.\n shifts_x = torch.arange(X_MIN, X_MAX - np.sign(VOXEL_X_SIZE) * 1e-10, step=VOXEL_X_SIZE,\n dtype=torch.float32).to(device) + VOXEL_X_SIZE / 2.\n shifts_z, shifts_x = torch.meshgrid(shifts_z, shifts_x)\n locations_bev = torch.stack([shifts_x, shifts_z], dim=-1)\n locations_bev = locations_bev.reshape(-1, 2)\n return locations_bev\n\ndef compute_centerness_targets(reg_targets):\n left_right = reg_targets[:, [0, 2]]\n top_bottom = reg_targets[:, [1, 3]]\n centerness = (left_right.min(dim=-1)[0] / left_right.max(dim=-1)[0]) * \\\n (top_bottom.min(dim=-1)[0] / top_bottom.max(dim=-1)[0])\n return torch.sqrt(centerness)\n\n# def compute_corners_R(dimensions, rot):\n# num_boxes = dimensions.shape[0]\n# h, w, l = torch.split( dimensions.view(num_boxes, 1, 3), [1, 1, 1], dim=2)\n# # zeros = torch.zeros((num_boxes, 1, 1), dtype=torch.float32).cuda()\n# corners = torch.cat([torch.cat([l/2, l/2, -l/2, -l/2, l/2, l/2, -l/2, -l/2], dim=2),\n# torch.cat([h/2, h/2, h/2, h/2, -h/2, -h/2, -h/2, -h/2], dim=2),\n# torch.cat([w/2, -w/2, -w/2, w/2, w/2, -w/2, -w/2, w/2], dim=2)], dim=1)\n# corners = torch.matmul(rot, corners)\n# return corners\n\n# def angle_to_bevrotation(sin, cos):\n# zeros = torch.zeros_like(sin)\n# rot_1 = torch.stack([cos, zeros, -sin], dim=1)\n# rot_2 = torch.stack([zeros, zeros+1., zeros], dim=1)\n# rot_3 = torch.stack([sin, zeros, cos], dim=1)\n# rot = torch.stack([rot_1, rot_2, rot_3], dim=1)\n# return rot\n\ndef convert_to_viewpoint_torch(ry, z, x):\n return ry + torch.atan2(z, x) - np.pi / 2\n\ndef convert_to_ry_torch(alpha, z, x):\n return alpha - torch.atan2(z, x) + np.pi / 2\n" ]	[ [ "torch.transpose", "torch.ones", "torch.cat", "torch.sqrt", "numpy.sign", "torch.stack", "torch.meshgrid", "torch.atan2" ] ]
meyer-lab/type-I-ckine-model	[ "bc0451610655633483a98ab450d20ef631479d2b" ]	[ "ckine/figures/figureC12.py" ]	[ "import os\nimport matplotlib.lines as mlines\nimport pandas as pds\nimport numpy as np\nfrom .figureCommon import subplotLabel, getSetup\nfrom ..flow import importF\nfrom ..PCA import sampleT\nfrom ..flow import gating, count_data\n\nfrom ..FCimports import compMatrix, applyMatrix\n\npath_here = os.path.dirname(os.path.dirname(__file__))\n\n\ndef makeFigure():\n \"\"\"Get a list of the axis objects and create a figure\"\"\"\n # Get list of axis objects\n ax, f = getSetup((10, 10), (4, 4))\n\n subplotLabel(ax)\n\n StatMV()\n\n # global_legend(ax[7])\n\n return f\n\n\ndef global_legend(ax):\n \"\"\" Create legend for Inverse and Standard Gini \"\"\"\n blue = mlines.Line2D([], [], color='navy', marker='o', linestyle='None', markersize=6, label='Gini Coeff')\n orange = mlines.Line2D([], [], color='darkorange', marker='o', linestyle='None', markersize=6, label='Inverse Gini Coeff')\n ax.legend(handles=[orange, blue], bbox_to_anchor=(0, 1), loc=\"upper left\")\n\n\ndef StatMV():\n \"\"\"\n Calculate mean and variance of a sample in a pandas dataframe, and plot.\n \"\"\"\n\n dataFiles = [\"/data/flow/2019-03-19 IL-2 and IL-15 treated pSTAT5 assay - Lymphocyte gated - Treg plate.zip\",\n \"/data/flow/2019-03-27 IL-2 and IL-15 treated pSTAT5 assay - Lymphocyte gated - Treg plate.zip\",\n \"/data/flow/2019-04-18 IL-2 and IL-15 treated pSTAT5 assay - Lymphocyte gated - Treg plate - NEW PBMC LOT/\",\n \"/data/flow/2019-03-15 IL-2 and IL-15 treated pSTAT5 assay - Lymphocyte gated - NK plate.zip\",\n \"/data/flow/2019-03-27 IL-2 and IL-15 treated pSTAT5 assay - Lymphocyte gated - NK plate.zip\",\n \"/data/flow/2019-04-18 IL-2 and IL-15 treated pSTAT5 assay - Lymphocyte gated - NK plate - NEW PBMC LOT.zip\"]\n dataFiles = [\"/home/brianoj/Tplate15\", \"/home/brianoj/Tplate27\", \"/home/brianoj/Tplate418\", \"/home/brianoj/Nkplate15\", \"/home/brianoj/Nkplate27\", \"/home/brianoj/Nkplate418\"]\n dates = [\"3/15/2019\", \"3/27/2019\", \"4/18/2019\", \"3/15/2019\", \"3/27/2019\", \"4/18/2019\"]\n rows = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']\n cellTypesT = ['treg', 'nonTreg']\n TitlesT = [\"Treg\", \"Thelper\"]\n masterMVdf = pds.DataFrame(columns={\"Date\", \"Time\", \"Cell\", \"Ligand\", \"Dose\", \"Mean\", \"Bin\", \"NumCells\"})\n MVdf = pds.DataFrame(columns={\"Date\", \"Time\", \"Cell\", \"Ligand\", \"Dose\", \"Mean\", \"Bin\", \"NumCells\"})\n alldata = []\n dosemat = np.array([[84, 28, 9.333333, 3.111, 1.037037, 0.345679, 0.115226, 0.038409, 0.012803, 0.004268, 0.001423, 0.000474]])\n repList = [0, 0, 0, 0, 0, 0]\n\n numBins = 4\n\n T_matrix = compMatrix(\"2019-11-08\", \"1\", \"A\") # Create matrix 1\n\n for i, filename in enumerate(dataFiles):\n if i < 3:\n Tcells = True\n else:\n Tcells = False\n\n if Tcells:\n statcol = \"RL1-H\"\n IL2RaCol = \"VL1-H\"\n for k, cell_type in enumerate(cellTypesT):\n for j, row in enumerate(rows):\n print(filename)\n sample, _ = importF(filename, row)\n if cell_type:\n for jj, subSample in enumerate(sample):\n sample[jj] = applyMatrix(subSample, T_matrix)\n gates = gating(cell_type, dates[i], True, repList[i])\n _, alldata = count_data(sample, gates, Tcells, True)\n else:\n for jj, samplejj in enumerate(sample):\n _, pstat, _ = sampleT(samplejj)\n alldata.append(pstat)\n\n for ii, _ in enumerate(sample): # get pstat data and put it into list form\n dat_array = alldata[ii]\n stat_array = dat_array[[statcol]]\n stat_array = stat_array.to_numpy()\n stat_array = stat_array.clip(min=1) # remove small percentage of negative pstat values\n IL2Ra_array = dat_array[[IL2RaCol]]\n IL2Ra_array = IL2Ra_array.to_numpy()\n IL2Ra_array = IL2Ra_array.clip(min=1)\n IL2Ra_array = IL2Ra_array / 1.5\n while np.amax(stat_array) > 100000:\n IL2Ra_array = np.reshape(IL2Ra_array[stat_array != np.amax(stat_array)], (-1, 1)) # Remove random exploding value\n stat_array = np.reshape(stat_array[stat_array != np.amax(stat_array)], (-1, 1)) # Remove random exploding value\n bins = np.logspace(np.log10(np.percentile(IL2Ra_array, 5)), np.log10(np.percentile(IL2Ra_array, 95)), num=numBins)\n\n for kk in range(0, bins.size - 1):\n binDat = stat_array[(IL2Ra_array > bins[kk]) & (IL2Ra_array < bins[kk + 1])]\n if stat_array.size == 0:\n MVdf = MVdf.append(pds.DataFrame.from_dict({\"Date\": dates[i], \"Time\": timeFunc(row), \"Cell\": TitlesT[k], \"Ligand\": cytFunc(row), \"Dose\": dosemat[0, ii], \"Mean\": [0],\n \"Bin\": [kk], \"NumCells\": 0, \"Bivalent\": [0]}))\n else:\n MVdf = MVdf.append(pds.DataFrame.from_dict({\"Date\": dates[i], \"Time\": timeFunc(row), \"Cell\": TitlesT[k], \"Ligand\": cytFunc(\n row), \"Dose\": dosemat[0, ii], \"Mean\": np.mean(binDat), \"Bin\": [kk + 1], \"NumCells\": [binDat.size], \"Bivalent\": [0]}))\n\n if j == 3 or j == 7:\n MVdf['Mean'] = MVdf['Mean'] - MVdf.loc[(MVdf.Dose <= 0.001423)].Mean.mean()\n masterMVdf = masterMVdf.append(MVdf)\n MVdf = pds.DataFrame(columns={\"Date\", \"Time\", \"Ligand\", \"Dose\", \"Mean\", \"Bin\", \"NumCells\", \"Bivalent\"})\n\n dataFiles = [\"/home/brianoj/Muteins 060-062 T/2019-04-19 IL2-060 IL2-062 Treg plate\",\n \"/home/brianoj/Muteins 088-097 T/2019-04-19 IL2-088 IL2-097 Treg plate\",\n \"/home/brianoj/Muteins 060-088 T/2019-05-02 IL2-060 IL2-088 Treg plate\",\n \"/home/brianoj/Muteins 062-097 T/2019-05-02 IL2-062 IL2-097 Treg plate\",\n \"/home/brianoj/Muteins 060-062 Nk/2019-04-19 IL2-060 IL2-062 NK plate\",\n \"/home/brianoj/Muteins 088-097 Nk/2019-04-19 IL2-088 IL2-097 NK plate\",\n \"/home/brianoj/Muteins 060-088 Nk/2019-05-02 IL2-060 IL2-088 NK plate\",\n \"/home/brianoj/Muteins 062-097 Nk/2019-05-02 IL2-062 IL2-097 NK plate\"]\n dates = [\"4/19/2019\", \"4/19/2019\", \"5/2/2019\", \"5/2/2019\", \"4/19/2019\", \"4/19/2019\", \"5/2/2019\", \"5/2/2019\"]\n repList = [0, 1, 0, 1, 0, 1, 0, 1]\n\n print(\"Starting Muteins\")\n\n for i, filename in enumerate(dataFiles):\n if i < 4:\n Tcells = True\n else:\n Tcells = False\n if Tcells:\n statcol = \"RL1-H\"\n for k, cell_type in enumerate(cellTypesT):\n for j, row in enumerate(rows):\n print(filename)\n sample, _ = importF(filename, row)\n if cell_type:\n for jj, subSample in enumerate(sample):\n sample[jj] = applyMatrix(subSample, T_matrix)\n gates = gating(cell_type, dates[i], True, repList[i])\n _, alldata = count_data(sample, gates, Tcells, True)\n else:\n for jj, samplejj in enumerate(sample):\n _, pstat, _ = sampleT(samplejj)\n alldata.append(pstat)\n\n for ii, _ in enumerate(sample): # get pstat data and put it into list form\n dat_array = alldata[ii]\n stat_array = dat_array[[statcol]]\n stat_array = stat_array.to_numpy()\n stat_array = stat_array.clip(min=1) # remove small percentage of negative pstat values\n IL2Ra_array = dat_array[[IL2RaCol]]\n IL2Ra_array = IL2Ra_array.to_numpy()\n IL2Ra_array = IL2Ra_array.clip(min=1)\n IL2Ra_array = IL2Ra_array / 1.5\n while np.amax(stat_array) > 100000:\n IL2Ra_array = np.reshape(IL2Ra_array[stat_array != np.amax(stat_array)], (-1, 1)) # Remove random exploding value\n stat_array = np.reshape(stat_array[stat_array != np.amax(stat_array)], (-1, 1)) # Remove random exploding value\n bins = np.logspace(np.log10(np.percentile(IL2Ra_array, 5)), np.log10(np.percentile(IL2Ra_array, 95)), num=numBins)\n timelig = mutFunc(row, filename)\n for kk in range(0, bins.size - 1):\n binDat = stat_array[(IL2Ra_array > bins[kk]) & (IL2Ra_array < bins[kk + 1])]\n if stat_array.size == 0:\n MVdf = MVdf.append(pds.DataFrame.from_dict({\"Date\": dates[i], \"Time\": timelig[0], \"Cell\": TitlesT[k], \"Ligand\": timelig[1], \"Dose\": dosemat[0, ii], \"Mean\": [0],\n \"Bin\": [kk], \"NumCells\": 0, \"Bivalent\": timelig[2]}))\n else:\n MVdf = MVdf.append(pds.DataFrame.from_dict({\"Date\": dates[i], \"Time\": timelig[0], \"Cell\": TitlesT[k], \"Ligand\": timelig[1],\n \"Dose\": dosemat[0, ii], \"Mean\": np.mean(binDat), \"Bin\": [kk + 1], \"NumCells\": [binDat.size], \"Bivalent\": timelig[2]}))\n if j == 3 or j == 7:\n MVdf['Mean'] = MVdf['Mean'] - MVdf.loc[(MVdf.Dose <= 0.001423)].Mean.mean()\n masterMVdf = masterMVdf.append(MVdf)\n MVdf = pds.DataFrame(columns={\"Date\", \"Time\", \"Ligand\", \"Dose\", \"Mean\", \"Bin\", \"NumCells\", \"Bivalent\"})\n\n masterMVdf.Mean = masterMVdf.Mean.clip(lower=0)\n masterMVdf = masterMVdf.loc[masterMVdf.Ligand != \"H16L N-term\"]\n masterMVdf.to_csv(\"WTDimericMutSingleCellDataBin.csv\", index=False)\n\n return MVdf\n\n\ndef timeFunc(letter):\n if letter == \"A\" or letter == \"E\":\n return 4.0\n elif letter == \"B\" or letter == \"F\":\n return 2.0\n elif letter == \"C\" or letter == \"G\":\n return 1.0\n elif letter == \"D\" or letter == \"H\":\n return 0.5\n\n\ndef cytFunc(letter):\n if letter == \"A\" or letter == \"B\" or letter == \"C\" or letter == \"D\":\n return \"IL2\"\n elif letter == \"E\" or letter == \"F\" or letter == \"G\" or letter == \"H\":\n return \"IL15\"\n\n\ndef mutFunc(letter, datafile):\n if datafile == \"/home/brianoj/Muteins 060-062 T/2019-04-19 IL2-060 IL2-062 Treg plate\" or datafile == \"/home/brianoj/Muteins 060-062 Nk/2019-04-19 IL2-060 IL2-062 NK plate\":\n if letter == \"A\":\n return [4.0, \"WT N-term\", 1]\n elif letter == \"B\":\n return [4.0, \"WT N-term\", 1]\n elif letter == \"C\":\n return [4.0, \"WT N-term\", 1]\n elif letter == \"D\":\n return [0.5, \"WT N-term\", 1]\n elif letter == \"E\":\n return [4.0, \"H16N N-term\", 1]\n elif letter == \"F\":\n return [2.0, \"H16N N-term\", 1]\n elif letter == \"G\":\n return [1.0, \"H16N N-term\", 1]\n elif letter == \"H\":\n return [2.0, \"WT N-term\", 1]\n\n elif datafile == \"/home/brianoj/Muteins 088-097 T/2019-04-19 IL2-088 IL2-097 Treg plate\" or datafile == \"/home/brianoj/Muteins 088-097 Nk/2019-04-19 IL2-088 IL2-097 NK plate\":\n if letter == \"A\":\n return [4.0, \"R38Q N-term\", 1]\n elif letter == \"B\":\n return [2.0, \"R38Q N-term\", 1]\n elif letter == \"C\":\n return [1.0, \"R38Q N-term\", 1]\n elif letter == \"D\":\n return [1.0, \"WT N-term\", 1]\n elif letter == \"E\":\n return [4.0, \"R38Q/H16N\", 1]\n elif letter == \"F\":\n return [2.0, \"R38Q/H16N\", 1]\n elif letter == \"G\":\n return [1.0, \"R38Q/H16N\", 1]\n elif letter == \"H\":\n return [0.5, \"R38Q/H16N\", 1]\n\n elif datafile == \"/home/brianoj/Muteins 060-088 T/2019-05-02 IL2-060 IL2-088 Treg plate\" or datafile == \"/home/brianoj/Muteins 060-088 Nk/2019-05-02 IL2-060 IL2-088 NK plate\":\n if letter == \"A\":\n return [4.0, \"WT N-term\", 1]\n elif letter == \"B\":\n return [4.0, \"WT N-term\", 1]\n elif letter == \"C\":\n return [4.0, \"WT N-term\", 1]\n elif letter == \"D\":\n return [0.5, \"WT N-term\", 1]\n elif letter == \"E\":\n return [4.0, \"R38Q N-term\", 1]\n elif letter == \"F\":\n return [2.0, \"R38Q N-term\", 1]\n elif letter == \"G\":\n return [1.0, \"R38Q N-term\", 1]\n elif letter == \"H\":\n return [2.0, \"R38Q N-term\", 1]\n\n elif datafile == \"/home/brianoj/Muteins 062-097 T/2019-05-02 IL2-062 IL2-097 Treg plate\" or datafile == \"/home/brianoj/Muteins 062-097 Nk/2019-05-02 IL2-062 IL2-097 NK plate\":\n if letter == \"A\":\n return [4.0, \"H16N N-term\", 1]\n elif letter == \"B\":\n return [2.0, \"H16N N-term\", 1]\n elif letter == \"C\":\n return [1.0, \"H16N N-term\", 1]\n elif letter == \"D\":\n return [1.0, \"H16N N-term\", 1]\n elif letter == \"E\":\n return [4.0, \"R38Q/H16N\", 1]\n elif letter == \"F\":\n return [2.0, \"R38Q/H16N\", 1]\n elif letter == \"G\":\n return [1.0, \"R38Q/H16N\", 1]\n elif letter == \"H\":\n return [0.5, \"R38Q/H16N\", 1]\n" ]	[ [ "numpy.amax", "matplotlib.lines.Line2D", "numpy.percentile", "pandas.DataFrame", "numpy.mean", "pandas.DataFrame.from_dict", "numpy.array" ] ]
ravising-h/Grad-CAM.pytorch	[ "e0a1ae3870ea189f9b4cd8782eb77bfb5293c31b" ]	[ "detection/demo_retinanet.py" ]	[ "# -- coding: utf-8 --\n\"\"\"\n @File : demo_retinanet.py\n @Time : 2020/5/16 下午9:59\n @Author : yizuotian\n @Description :\n\"\"\"\n\nimport argparse\nimport multiprocessing as mp\nimport os\n\nfrom tqdm import tqdm\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.axes_grid1 import ImageGrid\nimport cv2\nimport detectron2.data.transforms as T\nimport numpy as np\nimport torch\nfrom detectron2.checkpoint import DetectionCheckpointer\nfrom detectron2.config import get_cfg\nfrom detectron2.data import MetadataCatalog\nfrom detectron2.data.detection_utils import read_image\nfrom detectron2.modeling import build_model\nfrom detectron2.utils.logger import setup_logger\nfrom skimage import io\n\nfrom grad_cam_retinanet import GradCAM, GradCamPlusPlus\n\n# constants\nWINDOW_NAME = \"COCO detections\"\n\n\ndef setup_cfg(args):\n # load config from file and command-line arguments\n cfg = get_cfg()\n cfg.merge_from_file(args.config_file)\n cfg.merge_from_list(args.opts)\n # Set score_threshold for builtin models\n cfg.MODEL.RETINANET.SCORE_THRESH_TEST = 0.25\n cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = args.confidence_threshold\n cfg.MODEL.PANOPTIC_FPN.COMBINE.INSTANCES_CONFIDENCE_THRESH = args.confidence_threshold\n cfg.freeze()\n return cfg\n\n\ndef norm_image(image):\n \"\"\"\n 标准化图像\n :param image: [H,W,C]\n :return:\n \"\"\"\n image = image.copy()\n image -= np.max(np.min(image), 0)\n image /= np.max(image)\n image = 255.\n return np.uint8(image)\n\n\ndef gen_cam(image, mask):\n \"\"\"\n 生成CAM图\n :param image: [H,W,C],原始图像\n :param mask: [H,W],范围0~1\n :return: tuple(cam,heatmap)\n \"\"\"\n # mask转为heatmap\n heatmap = cv2.applyColorMap(np.uint8(255 mask), cv2.COLORMAP_JET)\n heatmap = np.float32(heatmap) / 255\n heatmap = heatmap[..., ::-1] # gbr to rgb\n\n # 合并heatmap到原始图像\n cam = heatmap + np.float32(image)\n return norm_image(cam), heatmap\n\n\ndef save_image(image_dicts, input_image_name, layer_name, network='retinanet', output_dir='./results'):\n prefix = os.path.splitext(input_image_name)[0]\n for key, image in image_dicts.items():\n if key == 'predict_box':\n io.imsave(os.path.join(output_dir,\n '{}-{}-{}.jpg'.format(prefix, network, key)),\n image)\n else:\n io.imsave(os.path.join(output_dir,\n '{}-{}-{}-{}.jpg'.format(prefix, network, layer_name, key)),\n (255 * image).astype(np.uint8) )\n\n\ndef get_parser():\n parser = argparse.ArgumentParser(description=\"Detectron2 demo for builtin models\")\n parser.add_argument(\n \"--config-file\",\n default=\"configs/quick_schedules/mask_rcnn_R_50_FPN_inference_acc_test.yaml\",\n metavar=\"FILE\",\n help=\"path to config file\",\n )\n parser.add_argument(\"--input\", help=\"A list of space separated input images\")\n parser.add_argument(\n \"--output\",\n help=\"A file or directory to save output visualizations. \"\n \"If not given, will show output in an OpenCV window.\",\n )\n\n parser.add_argument(\n \"--confidence-threshold\",\n type=float,\n default=0.2,\n help=\"Minimum score for instance predictions to be shown\",\n )\n parser.add_argument(\n \"--opts\",\n help=\"Modify config options using the command-line 'KEY VALUE' pairs\",\n default=[],\n nargs=argparse.REMAINDER,\n )\n parser.add_argument('--layer-name', type=str, default='head.cls_subnet.2',\n help='使用哪层特征去生成CAM')\n return parser\n\n\ndef main(args):\n from detectron2.data.datasets import register_coco_instances\n register_coco_instances(\"Dent_Detection_train\", {}, \"/content/drive/MyDrive/Damage/Dataset/coco_15k_balanced/annotations/instance_train2017.json\", \"/content/drive/MyDrive/Damage/Dataset/coco_15k_balanced/JPEGImages\")\n register_coco_instances(\"Dent_Detection_test\", {}, \"/content/drive/MyDrive/Damage/Dataset/coco_15k_balanced/annotations/instance_val2017.json\", \"/content/drive/MyDrive/Damage/Dataset/coco_15k_balanced/JPEGImages\")\n MetadataCatalog.get(\"Dent_Detection_test\").thing_classes = ['Dent']\n setup_logger(name=\"fvcore\")\n logger = setup_logger()\n logger.info(\"Arguments: \" + str(args))\n\n cfg = setup_cfg(args)\n print(cfg)\n \n model = build_model(cfg)\n\n checkpointer = DetectionCheckpointer(model)\n checkpointer.load(cfg.MODEL.WEIGHTS)\n\n\n path = os.path.expanduser(args.input)\n original_image = read_image(path, format=\"BGR\")\n height, width = original_image.shape[:2]\n transform_gen = T.ResizeShortestEdge(\n [cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST], cfg.INPUT.MAX_SIZE_TEST\n )\n image = transform_gen.get_transform(original_image).apply_image(original_image)\n image = torch.as_tensor(image.astype(\"float32\").transpose(2, 0, 1)).requires_grad_(True)\n\n inputs = {\"image\": image, \"height\": height, \"width\": width}\n\n # Grad-CAM\n img_grid = [0]18\n for ly in tqdm(range(8), desc =\"LAYER BY LAYER\"):\n layer_name = f'head.cls_subnet.{ly}'\n grad_cam = GradCAM(model, layer_name)\n mask, box, class_id = grad_cam(inputs) # cam mask\n grad_cam.remove_handlers()\n\n #\n image_dict = {}\n img = original_image[..., ::-1]\n x1, y1, x2, y2 = box\n image_dict['predict_box'] = img[y1:y2, x1:x2]\n img_grid[0], img_grid[9] = image_dict['predict_box'] , image_dict['predict_box'] \n image_cam, image_dict['heatmap'] = gen_cam(img[y1:y2, x1:x2], mask[y1:y2, x1:x2])\n img_grid[ly+1] = (image_dict['heatmap']255).astype(np.uint8)\n \n # Grad-CAM++\n grad_cam_plus_plus = GradCamPlusPlus(model, layer_name)\n mask_plus_plus = grad_cam_plus_plus(inputs) # cam mask\n\n _, image_dict['heatmap++'] = gen_cam(img[y1:y2, x1:x2], mask_plus_plus[y1:y2, x1:x2])\n img_grid[ly+9] = (image_dict['heatmap++']*255).astype(np.uint8)\n grad_cam_plus_plus.remove_handlers()\n\n # 获取类别名称\n meta = MetadataCatalog.get(\n cfg.DATASETS.TEST[0] if len(cfg.DATASETS.TEST) else \"__unused\"\n )\n label = meta.thing_classes[class_id]\n\n print(\"label:{}\".format(label))\n \n fig = plt.figure(figsize=(20., 6.))\n grid = ImageGrid(fig, 111, # similar to subplot(111)\n nrows_ncols=(2, 9), # creates 2x2 grid of axes\n axes_pad=0.1, # pad between axes in inch.\n )\n\n for ax, im_ in zip(grid, img_grid):\n # Iterating over the grid returns the Axes.\n ax.imshow(cv2.addWeighted(im_, 0.6, img_grid[0], 0.4, 0.2))\n \n plt.savefig(os.path.join(output_dir, f'{os.path.basename(path)}-grid.jpg'))\n # save_image(image_dict, os.path.basename(path), args.layer_name)\n\n\nif __name__ == \"__main__\":\n \"\"\"\n Usage:export KMP_DUPLICATE_LIB_OK=TRUE\n python detection/demo_retinanet.py --config-file detection/retinanet_R_50_FPN_3x.yaml \\\n --input ./examples/pic1.jpg \\\n --layer-name head.cls_subnet.7 \\\n --opts MODEL.WEIGHTS /Users/yizuotian/pretrained_model/model_final_4cafe0.pkl MODEL.DEVICE cpu\n \"\"\"\n mp.set_start_method(\"spawn\", force=True)\n arguments = get_parser().parse_args()\n main(arguments)\n" ]	[ [ "numpy.min", "numpy.uint8", "numpy.max", "numpy.float32", "matplotlib.pyplot.figure" ] ]
sayan2207/Class-Predictor	[ "191d98ca4d10d75fef24a4b6b78022c57679d4bc" ]	[ "predict_class_sklearn.py" ]	[ "import numpy as np\nimport random\nimport scipy.stats as ss\nimport matplotlib.pyplot as plt\nfrom matplotlib.colors import ListedColormap as lcm\nfrom sklearn.neighbors import KNeighborsClassifier as knc\nfrom time import strftime as stime\nimport os\n\ndef synthetic_plot(limits=(-5,5,-5,5), unit=0.1, no_of_points=20, no_of_classes=2, k=5):\n (predictors, outcomes) = generate_synth_data(no_of_points, no_of_classes)\n \n genuine_plot(predictors, outcomes, limits, unit, k)\n \ndef genuine_plot(predictors, outcomes, limits=(-5,5,-5,5), unit=0.1, k=5, home=False):\n (xx, yy, prediction_grid) = make_prediction_grid(predictors, outcomes, limits, unit, k)\n \n plot_prediction_grid(xx, yy, prediction_grid, predictors, outcomes);\n\n\ndef plot_prediction_grid (xx, yy, predicted_grid, predictors, outcomes):\n \"\"\" Plot KNN predictions for every point on the grid.\"\"\"\n \n types = len( set( outcomes ) )\n \n c_bg = np.zeros((types,3))\n c_ob = np.zeros((types,3))\n \n for i in range(types):\n c_bg_i = np.array([random.randint(100,255) / 255, random.randint(100,255) / 255, random.randint(100,255) / 255])\n c_ob_i = (c_bg_i*255 - 50)/255\n \n c_bg[i] = c_bg_i\n c_ob[i] = c_ob_i\n \n \n background_colormap = lcm(c_bg)\n observation_colormap = (c_ob)\n \n plt.figure( figsize =(10,10) )\n \n plt.pcolormesh(xx, yy, predicted_grid, cmap = background_colormap, alpha = 0.5)\n \n xs = np.array(predictors[:,0])\n ys = np.array(predictors[:,1])\n outcomes = np.array( outcomes )\n \n \n for i in range(types):\n to_plot = outcomes==i\n plt.scatter(xs[to_plot] , ys[to_plot] ,s = 50,color=observation_colormap[i] , label=\"Class \"+str(i+1))\n \n plt.xlabel('Variable 1'); plt.ylabel('Variable 2')\n \n x_labels = np.linspace( np.min(xx), np.max(xx), 5 )\n y_labels = np.linspace( np.min(yy), np.max(yy), 5 )\n \n plt.xticks(x_labels, rotation=\"vertical\")\n plt.yticks(y_labels)\n \n plt.xlim (np.min(xx), np.max(xx))\n plt.ylim (np.min(yy), np.max(yy))\n \n plt.legend(loc=\"lower right\")\n \n if not os.path.exists(\"Plots\"):\n os.makedirs(\"Plots\")\n \n filename = \"Plots\\plot_\" + stime(\"%d-%m-%Y_%H-%M-%S\") + \".pdf\"\n plt.savefig(filename)\n plt.show()\n\ndef make_prediction_grid(points, outcomes, limits, steps=1, k=5):\n (x_min, x_max, y_min, y_max) = limits\n xs = np.arange(x_min, x_max, steps)\n ys = np.arange(y_min, y_max, steps)\n \n \n knn = knc(n_neighbors=k)\n knn.fit(points,outcomes)\n \n (xx, yy) = np.meshgrid(xs, ys)\n \n prediction_grid = np.zeros(xx.shape, dtype=int)\n \n \n for i,x in enumerate(xs):\n for j,y in enumerate(ys):\n p = np.array([x,y])\n prediction_grid[j,i] = knn.predict([p])[0]\n \n return (xx, yy, prediction_grid)\n \n\ndef generate_synth_data(n=50,types=2):\n points = ss.norm(0 , 1).rvs((n,2))\n outcomes = np.repeat(0 , n)\n for i in range(1,types):\n points = np.concatenate( (points, ss.norm(i , 1).rvs((n,2)) ), axis=0 )\n outcomes = np.concatenate( (outcomes, np.repeat(i,n)) )\n return (points, outcomes)\n\n\n" ]	[ [ "matplotlib.pyplot.legend", "numpy.max", "numpy.arange", "sklearn.neighbors.KNeighborsClassifier", "numpy.repeat", "numpy.zeros", "matplotlib.pyplot.figure", "numpy.min", "matplotlib.pyplot.savefig", "matplotlib.colors.ListedColormap", "matplotlib.pyplot.pcolormesh", "numpy.meshgrid", "numpy.array", "matplotlib.pyplot.show", "matplotlib.pyplot.xticks", "matplotlib.pyplot.ylabel", "scipy.stats.norm", "matplotlib.pyplot.xlabel", "matplotlib.pyplot.yticks" ] ]
apigott/dra	[ "c2f24d9ef6d9d8cb78c5a058574cec8e132afd4f" ]	[ "dragg/reformat.py" ]	[ "import os\nimport sys\nimport json\nimport toml\nfrom datetime import datetime, timedelta\nimport numpy as np\nimport pandas as pd\nimport itertools as it\nimport random\n\nimport plotly.graph_objects as go\nimport plotly.express as px\nfrom plotly.subplots import make_subplots\nimport plotly.io as pio\nimport plotly\nfrom prettytable import PrettyTable\n\nfrom dragg.logger import Logger\n\nclass Reformat:\n def __init__(self):\n self.log = Logger(\"reformat\")\n\n self.data_dir = os.path.expanduser(os.environ.get('DATA_DIR','data'))\n self.outputs_dir = os.path.expanduser(os.environ.get('OUTPUT_DIR','outputs'))\n if not os.path.isdir(self.outputs_dir):\n self.log.logger.error(\"No outputs directory found.\")\n quit()\n self.config_file = os.path.join(self.data_dir, os.environ.get('CONFIG_FILE', 'config.toml'))\n self.config = self._import_config()\n\n self.add_date_ranges()\n self.add_mpc_params()\n self.date_folders = self.set_date_folders()\n self.mpc_folders = self.set_mpc_folders()\n self.files = self.set_files()\n\n self.fig_list = None\n self.save_path = os.path.join('outputs', 'images', datetime.now().strftime(\"%m%dT%H%M%S\"))\n\n def main(self):\n # put a list of plotting functions here\n self.sample_home = \"Crystal-RXXFA\"\n self.plots = [self.rl2baseline,\n self.plot_single_home]\n\n self.images = self.plot_all()\n\n def plot_all(self, save_images=False):\n figs = []\n for plot in self.plots:\n fig = make_subplots(specs=[[{\"secondary_y\": True}]])\n fig.update_layout(\n font=dict(\n size=65,\n )\n )\n fig.update_xaxes(\n title_standoff=80\n )\n fig.update_yaxes(\n title_standoff=60\n )\n fig = plot(fig)\n fig.show()\n figs += [fig]\n return figs\n\n def save_images(self):\n if not os.path.isdir(self.save_path):\n os.makedirs(self.save_path)\n for img in self.images:\n self.log.logger.info(f\"Saving images of outputs to timestamped folder at {self.save_path}.\")\n try:\n path = os.path.join(self.save_path, f\"{img.layout.title.text}.png\")\n pio.write_image(img, path, width=1024, height=768)\n except:\n self.log.logger.error(\"Could not save plotly image(s) to outputs directory.\")\n\n def add_date_ranges(self):\n start_dates = set([datetime.strptime(self.config['simulation']['start_datetime'], '%Y-%m-%d %H')])\n end_dates = set([datetime.strptime(self.config['simulation']['end_datetime'], '%Y-%m-%d %H')])\n temp = {\"start_datetime\": start_dates, \"end_datetime\": end_dates}\n self.date_ranges = temp\n\n def add_mpc_params(self):\n n_houses = self.config['community']['total_number_homes']\n mpc_horizon = self.config['home']['hems']['prediction_horizon']\n dt = self.config['home']['hems']['sub_subhourly_steps']\n solver = self.config['home']['hems']['solver']\n check_type = self.config['simulation']['check_type']\n agg_interval = self.config['agg']['subhourly_steps']\n temp = {\"n_houses\": set([n_houses]), \"mpc_prediction_horizons\": set([mpc_horizon]), \"mpc_hourly_steps\": set([dt]), \"check_type\": set([check_type]), \"agg_interval\": set([agg_interval]), \"solver\": set([solver])}\n # for key in temp:\n # if key in additional_params:\n # temp[key] \|= set(additional_params[key])\n self.mpc_params = temp\n\n self.versions = set([self.config['simulation']['named_version']])\n\n def set_date_folders(self):\n temp = []\n # self.date_ranges['mpc_steps'] = set([self.config['home']['hems']['sub_subhourly_steps']])\n # self.date_ranges['rl_steps'] = set([self.config['agg']['subhourly_steps']])\n keys, values = zip(self.date_ranges.items())\n permutations = [dict(zip(keys, v)) for v in it.product(values)]\n permutations = sorted(permutations, key=lambda i: i['end_datetime'], reverse=True)\n\n for i in permutations:\n date_folder = os.path.join(self.outputs_dir, f\"{i['start_datetime'].strftime('%Y-%m-%dT%H')}_{i['end_datetime'].strftime('%Y-%m-%dT%H')}\")\n self.log.logger.info(f\"Looking for files in: {date_folder}.\")\n if os.path.isdir(date_folder):\n hours = i['end_datetime'] - i['start_datetime']\n hours = int(hours.total_seconds() / 3600)\n\n new_folder = {\"folder\": date_folder, \"hours\": hours, \"start_dt\": i['start_datetime']}\n temp.append(new_folder)\n\n if len(temp) == 0:\n self.log.logger.error(\"No files found for the date ranges specified.\")\n exit()\n\n return temp\n\n def set_mpc_folders(self):\n temp = []\n keys, values = zip(self.mpc_params.items())\n permutations = [dict(zip(keys, v)) for v in it.product(values)]\n for j in self.date_folders:\n for i in permutations:\n mpc_folder = os.path.join(j[\"folder\"], f\"{i['check_type']}-homes_{i['n_houses']}-horizon_{i['mpc_prediction_horizons']}-interval_{60 // i['agg_interval']}-{60 // i['mpc_hourly_steps'] // i['agg_interval']}-solver_{i['solver']}\")\n if os.path.isdir(mpc_folder):\n timesteps = j['hours'] * i['agg_interval']\n minutes = 60 // i['agg_interval']\n x_lims = [j['start_dt'] + timedelta(minutes=minutesx) for x in range(timesteps)]\n\n set = {'path': mpc_folder, 'agg_dt': i['agg_interval'], 'ts': timesteps, 'x_lims': x_lims,}\n if not mpc_folder in temp:\n temp.append(set)\n for x in temp:\n print(x['path'])\n return temp\n\n def set_files(self):\n temp = []\n keys, values = zip(self.mpc_params.items())\n permutations = [dict(zip(keys, v)) for v in it.product(values)]\n\n color_families = [['rgb(204,236,230)','rgb(153,216,201)','rgb(102,194,164)','rgb(65,174,118)','rgb(35,139,69)','rgb(0,88,36)'],\n ['rgb(191,211,230)','rgb(158,188,218)','rgb(140,150,198)','rgb(140,107,177)','rgb(136,65,157)','rgb(110,1,107)'],\n ['rgb(217,217,217)','rgb(189,189,189)','rgb(150,150,150)','rgb(115,115,115)','rgb(82,82,82)','rgb(37,37,37)'],\n ['rgb(253,208,162)','rgb(253,174,107)','rgb(253,141,60)','rgb(241,105,19)','rgb(217,72,1)','rgb(140,45,4)'],]\n c = 0\n d = 0\n dash = [\"solid\", \"dash\", \"dot\", \"dashdot\"]\n for j in self.mpc_folders:\n path = j['path']\n for i in permutations:\n for k in self.versions:\n dir = os.path.join(path, f\"version-{k}\")\n for case_dir in os.listdir(dir):\n file = os.path.join(dir, case_dir, \"results.json\")\n if os.path.isfile(file):\n name = f\"{case_dir}, v = {k}\"\n set = {\"results\": file, \"name\": name, \"parent\": j, \"color\": color_families[c][d], \"dash\":dash[c]}\n temp.append(set)\n self.log.logger.info(f\"Adding baseline file at {file}\")\n d = (d + 1) % len(color_families[c])\n c = (c + 1) % len(color_families)\n\n return temp\n\n def get_type_list(self, type):\n type_list = set([])\n i = 0\n for file in self.files:\n with open(file[\"results\"]) as f:\n data = json.load(f)\n\n temp = set([])\n for name, house in data.items():\n try:\n if house[\"type\"] == type:\n temp.add(name)\n except:\n pass\n\n if i < 1:\n type_list = temp\n else:\n type_list = type_list.intersection(temp)\n\n self.log.logger.info(f\"{len(type_list)} homes found of type {type}: {type_list}\")\n return type_list\n\n def _import_config(self):\n if not os.path.exists(self.config_file):\n self.log.logger.error(f\"Configuration file does not exist: {self.config_file}\")\n sys.exit(1)\n\n with open(self.config_file, 'r') as f:\n data = toml.load(f)\n\n return data\n\n def plot_environmental_values(self, name, fig, summary, file, fname):\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=summary[\"OAT\"][0:file[\"parent\"][\"ts\"]], name=f\"OAT (C)\", visible='legendonly'))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=summary[\"GHI\"][0:file[\"parent\"][\"ts\"]], name=f\"GHI\", line={'color':'goldenrod', 'width':8}, visible='legendonly'))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=summary[\"TOU\"][0:file[\"parent\"][\"ts\"]], name=f\"TOU Price ($/kWh)\", line_shape='hv', visible='legendonly'), secondary_y=True)\n fig = self.plot_thermal_bounds(fig, file['parent']['x_lims'], name, fname)\n return fig\n\n def plot_thermal_bounds(self, fig, x_lims, name, fname):\n ah_file = os.path.join(self.outputs_dir, f\"all_homes-{self.config['community']['total_number_homes']}-config.json\")\n with open(ah_file) as f:\n data = json.load(f)\n\n for dict in data:\n if dict['name'] == name:\n data = dict\n\n fig.add_trace(go.Scatter(x=x_lims, y=data['hvac']['temp_in_min'] np.ones(len(x_lims)), name=f\"Tin_min\", fill=None, showlegend=False, mode='lines', line_color='lightsteelblue'))\n fig.add_trace(go.Scatter(x=x_lims, y=data['hvac']['temp_in_max'] * np.ones(len(x_lims)), name=f\"Tin_bounds\", fill='tonexty' , mode='lines', line_color='lightsteelblue'))\n\n fig.add_trace(go.Scatter(x=x_lims, y=data['wh']['temp_wh_min'] * np.ones(len(x_lims)), name=f\"Twh_min\", fill=None, showlegend=False, mode='lines', line_color='pink'))\n fig.add_trace(go.Scatter(x=x_lims, y=data['wh']['temp_wh_max'] * np.ones(len(x_lims)), name=f\"Twh_bounds\", fill='tonexty' , mode='lines', line_color='pink'))\n return fig\n\n def plot_base_home(self, name, fig, data, summary, fname, file, plot_price=True):\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=data[\"temp_in_opt\"], name=f\"Tin - {fname}\", legendgroup='tin', line={'color':'blue', 'width':8, 'dash':file['dash']}))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=data[\"temp_wh_opt\"], showlegend=True, legendgroup='twh', name=f\"Twh - {fname}\", line={'color':'firebrick', 'width':8, 'dash':file['dash']}))\n\n fig.update_layout(legend=dict(\n yanchor=\"top\",\n y=0.99,\n xanchor=\"left\",\n x=0.03,\n font=dict(\n size=65),\n ),\n yaxis_title=\"Temperature (deg C)\"\n )\n\n return fig\n\n def plot_pv(self, name, fig, data, fname, file):\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=data[\"p_pv_opt\"], name=f\"Ppv (kW)\", line_color='orange', line_shape='hv', visible='legendonly'))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=data[\"u_pv_curt_opt\"], name=f\"U_pv_curt (kW) - {fname}\", line_shape='hv', visible='legendonly'))\n return fig\n\n def plot_battery(self, name, fig, data, fname, file):\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=data[\"e_batt_opt\"], name=f\"SOC (kW) - {fname}\", line_shape='hv', visible='legendonly'))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=data[\"p_batt_ch\"], name=f\"Pch (kW) - {fname}\", line_shape='hv', visible='legendonly'))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=data[\"p_batt_disch\"], name=f\"Pdis (kW) - {fname}\", line_shape='hv', visible='legendonly'))\n return fig\n\n def plot_single_home(self, fig):\n if self.sample_home is None:\n if type is None:\n type = \"base\"\n self.log.logger.warning(\"Specify a home type or name. Proceeding with home of type: \\\"base\\\".\")\n\n type_list = self._type_list(type)\n self.sample_home = random.sample(type_list,1)[0]\n self.log.logger.info(f\"Proceeding with home: {name}\")\n\n flag = False\n for file in self.files:\n with open(file[\"results\"]) as f:\n comm_data = json.load(f)\n\n try:\n data = comm_data[self.sample_home]\n except:\n self.log.logger.error(f\"No home with name: {self.sample_home}\")\n return\n\n type = data[\"type\"]\n summary = comm_data[\"Summary\"]\n\n if not flag:\n fig = self.plot_environmental_values(self.sample_home, fig, summary, file, file[\"name\"])\n flag = True\n\n fig.update_xaxes(title_text=\"Time of Day (hour)\")\n fig.update_layout(title_text=f\"{self.sample_home} - {type} type\")\n\n fig = self.plot_base_home(self.sample_home, fig, data, summary, file[\"name\"], file)\n\n if 'pv' in type:\n fig = self.plot_pv(self.sample_home, fig, data, file[\"name\"], file)\n\n if 'batt' in type:\n fig = self.plot_battery(self.sample_home, fig, data, file[\"name\"], file)\n\n return fig\n\n def plot_all_homes(self, fig=None):\n homes = [\"Crystal-RXXFA\",\"Myles-XQ5IA\",\"Lillie-NMHUH\",\"Robert-2D73X\",\"Serena-98EPE\",\"Gary-U95TS\",\"Bruno-PVRNB\",\"Dorothy-9XMNY\",\"Jason-INS3S\",\"Alvin-4BAYB\",]\n for self.sample_home in homes:\n fig = make_subplots(specs=[[{\"secondary_y\": True}]])\n fig.update_layout(\n font=dict(\n size = 12\n )\n )\n fig = self.plot_single_home(fig)\n\n return\n\n def plot_baseline(self, fig):\n for file in self.files:\n with open(file[\"results\"]) as f:\n data = json.load(f)\n\n ts = len(data['Summary']['p_grid_aggregate'])-1\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=data[\"Summary\"][\"p_grid_aggregate\"], name=f\"Agg Load - {file['name']}\", line_shape='hv', line={'color':file['color'], 'width':4, 'dash':'solid'}))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=np.cumsum(np.divide(data[\"Summary\"][\"p_grid_aggregate\"], file['parent']['agg_dt'])), name=f\"Cumulative Agg Load - {file['name']}\", line_shape='hv', visible='legendonly', line={'color':file['color'], 'width':4, 'dash':'dash'}))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=np.divide(np.cumsum(data[\"Summary\"][\"p_grid_aggregate\"]), np.arange(ts + 1) + 1), name=f\"Avg Cumulative Agg Load - {file['name']}\", line_shape='hv', visible='legendonly', line={'color':file['color'], 'width':4, 'dash':'dashdot'}))\n return fig\n\n def plot_typ_day(self, fig):\n rl_counter = 0\n tou_counter = 0\n dn_counter = 0\n for file in self.files:\n flag = True\n\n with open(file[\"results\"]) as f:\n data = json.load(f)\n\n name = file[\"name\"]\n\n ts = len(data['Summary']['p_grid_aggregate'])-1\n rl_setpoint = data['Summary']['p_grid_setpoint']\n if 'clipped' in file['name']:\n rl_setpoint = np.clip(rl_setpoint, 45, 60)\n loads = np.array(data[\"Summary\"][\"p_grid_aggregate\"])\n loads = loads[:len(loads) // (24file['parent']['agg_dt']) 24 * file['parent']['agg_dt']]\n if len(loads) > 24:\n daily_max_loads = np.repeat(np.amax(loads.reshape(-1, 24file['parent']['agg_dt']), axis=1), 24file['parent']['agg_dt'])\n daily_min_loads = np.repeat(np.amin(loads.reshape(-1, 24file['parent']['agg_dt']), axis=1), 24file['parent']['agg_dt'])\n daily_range_loads = np.subtract(daily_max_loads, daily_min_loads)\n daily_range_loads = [abs(loads[max(i-6, 0)] - loads[min(i+6, len(loads)-1)]) for i in range(len(loads))]\n daily_avg_loads = np.repeat(np.mean(loads.reshape(-1, 24file['parent']['agg_dt']), axis=1), 24file['parent']['agg_dt'])\n daily_std_loads = np.repeat(np.std(loads.reshape(-1, 24file['parent']['agg_dt']), axis=1), 24file['parent']['agg_dt'])\n daily_std_loads = [np.std(loads[max(i-6, 0):i+6]) for i in range(len(loads))]\n\n composite_day = np.average(loads.reshape(-1, 24file['parent']['agg_dt']), axis=0)\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=composite_day, name=f\"{name}\", opacity=0.5, showlegend=flag, line={'color':clr, 'width':8, 'dash':dash}))\n\n fig.update_layout(legend=dict(\n yanchor=\"top\",\n y=0.45,\n xanchor=\"left\",\n x=0.7\n ))\n\n fig.update_layout(\n font=dict(\n # family=\"Courier New, monospace\",\n size=65,\n ),\n title=\"Avg Daily Load Profile\",\n xaxis_title=\"Time of Day\",\n yaxis_title=\"Agg. Demand (kW)\"\n )\n\n fig.update_xaxes(\n title_standoff=80\n )\n fig.update_yaxes(\n title_standoff=60\n )\n\n return fig\n\n def plot_max_and_12hravg(self, fig):\n for file in self.files:\n # all_avgs.add_column()\n clr = file['color']\n\n with open(file[\"results\"]) as f:\n data = json.load(f)\n\n name = file[\"name\"]\n ts = len(data['Summary']['p_grid_aggregate'])-1\n rl_setpoint = data['Summary']['p_grid_setpoint']\n if 'clipped' in file['name']:\n rl_setpoint = np.clip(rl_setpoint, 45, 60)\n loads = np.array(data[\"Summary\"][\"p_grid_aggregate\"])\n loads = loads[:len(loads) // (24file['parent']['agg_dt']) * 24 * file['parent']['agg_dt']]\n if len(loads) > 24:\n daily_max_loads = np.repeat(np.amax(loads.reshape(-1, 24file['parent']['agg_dt']), axis=1), 24file['parent']['agg_dt'])\n daily_min_loads = np.repeat(np.amin(loads.reshape(-1, 24file['parent']['agg_dt']), axis=1), 24file['parent']['agg_dt'])\n daily_range_loads = np.subtract(daily_max_loads, daily_min_loads)\n daily_range_loads = [abs(loads[max(i-6, 0)] - loads[min(i+6, len(loads)-1)]) for i in range(len(loads))]\n daily_avg_loads = np.repeat(np.mean(loads.reshape(-1, 24file['parent']['agg_dt']), axis=1), 24file['parent']['agg_dt'])\n daily_std_loads = np.repeat(np.std(loads.reshape(-1, 24file['parent']['agg_dt']), axis=1), 24file['parent']['agg_dt'])\n\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=daily_max_loads, name=f\"{name} - Daily Max\", line_shape='hv', opacity=1, legendgroup=\"first\", line={'color':'firebrick', 'dash':dash, 'width':8}))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=rl_setpoint, name=f\"{name} - 12 Hr Avg\", opacity=0.5, legendgroup=\"second\", line={'color':'blue', 'dash':dash, 'width':8}))\n\n fig.update_layout(legend=dict(\n yanchor=\"top\",\n y=0.8,\n xanchor=\"left\",\n x=0.7\n ))\n\n fig.update_layout(\n font=dict(\n size=65,\n ),\n title=\"12 Hour Avg and Daily Max\",\n yaxis_title=\"Agg. Demand (kW)\"\n )\n\n fig.update_xaxes(\n title_standoff=80\n )\n fig.update_yaxes(\n title_standoff=60\n )\n\n return fig\n\n\n def plot_parametric(self, fig):\n all_daily_stats = PrettyTable(['run name', 'avg daily max', 'std daily max','overall max', 'avg daily range'])\n for file in self.files:\n clr = file['color']\n\n with open(file[\"results\"]) as f:\n data = json.load(f)\n\n name = file[\"name\"]\n ts = len(data['Summary']['p_grid_aggregate'])-1\n rl_setpoint = data['Summary']['p_grid_setpoint']\n if 'clipped' in file['name']:\n rl_setpoint = np.clip(rl_setpoint, 45, 60)\n loads = np.array(data[\"Summary\"][\"p_grid_aggregate\"])\n loads = loads[:len(loads) // (24file['parent']['agg_dt']) 24 * file['parent']['agg_dt']]\n if len(loads) >= 24:\n daily_max_loads = np.repeat(np.amax(loads.reshape(-1, 24file['parent']['agg_dt']), axis=1), 24file['parent']['agg_dt'])\n daily_min_loads = np.repeat(np.amin(loads.reshape(-1, 24file['parent']['agg_dt']), axis=1), 24file['parent']['agg_dt'])\n daily_range_loads = np.subtract(daily_max_loads, daily_min_loads)\n daily_range_loads = [abs(loads[max(i-6, 0)] - loads[min(i+6, len(loads)-1)]) for i in range(len(loads))]\n daily_avg_loads = np.repeat(np.mean(loads.reshape(-1, 24file['parent']['agg_dt']), axis=1), 24file['parent']['agg_dt'])\n daily_std_loads = [np.std(loads[max(i-6, 0):i+6]) for i in range(len(loads))]\n\n composite_day = np.average(loads.reshape(-1, 24file['parent']['agg_dt']), axis=0)\n fig.update_layout(legend=dict(\n yanchor=\"top\",\n y=0.45,\n xanchor=\"left\",\n x=0.5\n ))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=rl_setpoint, name=f\"{name} - 12 Hr Avg\", opacity=0.5, line={'color':clr, 'width':8}))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=data[\"Summary\"][\"p_grid_aggregate\"], name=f\"Agg Load - RL - {name}\", line_shape='hv', line={'color':clr}))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=daily_max_loads, name=f\"{name} - Daily Max\", line_shape='hv', opacity=0.5, line={'color':clr, 'dash':'dot'}))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=daily_min_loads, name=f\"Daily Min Agg Load - RL - {name}\", line_shape='hv', opacity=0.5, line={'color':clr, 'dash':'dash'}))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=daily_range_loads, name=f\"Daily Agg Load Range - RL - {name}\", line_shape='hv', opacity=0.5, line={'color':clr}))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=np.average(daily_range_loads) np.ones(len(loads)), name=f\"Avg Daily Agg Load Range - RL - {name}\", line_shape='hv', opacity=0.5, line={'color':clr}))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=daily_avg_loads, name=f\"Daily Avg Agg Load - RL - {name}\", line_shape='hv', opacity=0.5, line={'color':clr, 'dash':'dash'}))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=daily_std_loads, name=f\"Daily Std Agg Load - RL - {name}\", line_shape='hv', opacity=0.5, line={'color':clr, 'dash':'dashdot'}))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=np.average(daily_std_loads) * np.ones(len(loads)), name=f\"Avg Daily Std Agg Load - RL - {name}\", line_shape='hv', opacity=0.5, line={'color':clr, 'dash':'dashdot'}))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=np.cumsum(np.divide(data[\"Summary\"][\"p_grid_aggregate\"],file['parent']['agg_dt'])), name=f\"{name}\", line_shape='hv', visible='legendonly', line={'color':clr, }))\n all_daily_stats.add_row([file['name'], np.average(daily_max_loads), np.std(daily_max_loads), max(daily_max_loads), np.average(daily_range_loads)])\n else:\n self.log.logger.warning(\"Not enough data collected to have daily stats, try running the aggregator for longer.\")\n print(all_daily_stats)\n return fig\n\n def rl2baseline(self, fig):\n if len(self.files) == 0:\n self.log.logger.warning(\"No aggregator runs found for analysis.\")\n return fig\n fig = self.plot_baseline(fig)\n fig = self.plot_parametric(fig)\n fig.update_layout(title_text=\"RL Baseline Comparison\")\n fig.update_layout(\n title=\"Avg Daily Load Profile\",\n xaxis_title=\"Time of Day\",\n yaxis_title=\"Agg. Demand (kWh)\",)\n return fig\n\n def all_rps(self, fig):\n for file in self.files:\n with open(file['results']) as f:\n data = json.load(f)\n\n rps = data['Summary']['RP']\n fig.add_trace(go.Histogram(x=rps, name=f\"{file['name']}\"), row=1, col=1)\n\n with open(file['q_results']) as f:\n data = json.load(f)\n data = data[\"horizon\"]\n mu = np.array(data[\"mu\"])\n std = self.config['agg']['parameters']['exploration_rate'][0]\n delta = np.subtract(mu, rps)\n\n fig.add_trace(go.Histogram(x=delta, name=f\"{file['name']}\"), row=2, col=1)\n fig.add_trace(go.Scatter(x=[-std, -std, std, std], y=[0, 0.3len(rps), 0.3len(rps), 0], fill=\"toself\"), row=2, col=1)\n return fig\n\nif __name__ == \"__main__\":\n r = Reformat()\n r.main()\n" ]	[ [ "numpy.clip", "numpy.arange", "numpy.subtract", "numpy.cumsum", "numpy.std", "numpy.average", "numpy.array", "numpy.divide" ] ]
NunoEdgarGFlowHub/entropica_qaoa	[ "bc9496320dbeadeac1302bda056e9d7b67607e30" ]	[ "entropica_qaoa/tests/test_vqe.py" ]	[ "\"\"\"\nTest that all the components of vqe play nicely together\n\"\"\"\n\nimport numpy as np\nimport pytest\nfrom scipy.optimize import minimize\n\nfrom pyquil.paulis import PauliSum, PauliTerm\nfrom pyquil.api import WavefunctionSimulator, local_qvm, get_qc\nfrom pyquil.quil import Program\nfrom pyquil.gates import RX, CNOT\n\nfrom entropica_qaoa.vqe.cost_function import (PrepareAndMeasureOnWFSim,\n PrepareAndMeasureOnQVM)\n\n\n# gonna need this program and hamiltonian for both tests. So define them globally\n# hamiltonian = PauliSum.from_compact_str(\"(-1.0)Z0Z1 + 0.8Z0 + (-0.5)Z1\")\nterm1 = PauliTerm(\"Z\", 0, -1)\nterm1 *= PauliTerm(\"Z\", 1)\nterm2 = PauliTerm(\"Z\", 0, 0.8)\nterm3 = PauliTerm(\"Z\", 1, -0.5)\nhamiltonian = PauliSum([term1, term2, term3])\n\nprepare_ansatz = Program()\nparams = prepare_ansatz.declare(\"params\", memory_type=\"REAL\", memory_size=4)\nprepare_ansatz.inst(RX(params[0], 0))\nprepare_ansatz.inst(RX(params[1], 1))\nprepare_ansatz.inst(CNOT(0, 1))\nprepare_ansatz.inst(RX(params[2], 0))\nprepare_ansatz.inst(RX(params[3], 1))\n\np0 = [0, 0, 0, 0]\n\n\[email protected]\ndef test_vqe_on_WFSim():\n sim = WavefunctionSimulator()\n cost_fun = PrepareAndMeasureOnWFSim(prepare_ansatz=prepare_ansatz,\n make_memory_map=lambda p: {\"params\": p},\n hamiltonian=hamiltonian,\n sim=sim,\n scalar_cost_function=True)\n\n with local_qvm():\n out = minimize(cost_fun, p0, tol=1e-3, method=\"COBYLA\")\n wf = sim.wavefunction(prepare_ansatz, {\"params\": out['x']})\n assert np.allclose(wf.probabilities(), [0, 0, 0, 1], rtol=1.5, atol=0.01)\n assert np.allclose(out['fun'], -1.3)\n assert out['success']\n\n\[email protected]\ndef test_vqe_on_QVM():\n p0 = [3.1, -1.5, 0, 0] # make it easier when sampling\n qvm = get_qc(\"2q-qvm\")\n with local_qvm():\n cost_fun = PrepareAndMeasureOnQVM(prepare_ansatz=prepare_ansatz,\n make_memory_map=lambda p: {\"params\": p},\n hamiltonian=hamiltonian,\n qvm=qvm,\n scalar_cost_function=True,\n nshots=4,\n base_numshots=50)\n out = minimize(cost_fun, p0, tol=1e-2, method=\"Cobyla\")\n print(out)\n assert np.allclose(out['fun'], -1.3, rtol=1.1)\n assert out['success']\n" ]	[ [ "scipy.optimize.minimize", "numpy.allclose" ] ]
manjavacas/drl-building	[ "6aaa117c0d02b0349af227939460adf31d8d40d9" ]	[ "agents/DQN.py" ]	[ "#!/usr/bin/python3\n\nimport gym\nimport energym\nimport argparse\nimport uuid\nimport mlflow\n\nimport numpy as np\n\nfrom energym.utils.callbacks import LoggerCallback, LoggerEvalCallback\nfrom energym.utils.wrappers import NormalizeObservation, LoggerWrapper\n\nfrom stable_baselines3 import DQN\nfrom stable_baselines3.common.callbacks import EvalCallback, BaseCallback, CallbackList\nfrom stable_baselines3.common.vec_env import DummyVecEnv\n\n\nparser = argparse.ArgumentParser()\nparser.add_argument('--environment', '-env', type=str, default=None)\nparser.add_argument('--episodes', '-ep', type=int, default=1)\nparser.add_argument('--learning_rate', '-lr', type=float, default=0.0001)\nparser.add_argument('--buffer_size', '-bf', type=int, default=1000000)\nparser.add_argument('--learning_starts', '-ls', type=int, default=50000)\nparser.add_argument('--batch_size', '-bs', type=int, default=32)\nparser.add_argument('--tau', '-t', type=float, default=1.0)\nparser.add_argument('--gamma', '-g', type=float, default=.99)\nparser.add_argument('--train_freq', '-tf', type=int, default=4)\nparser.add_argument('--gradient_steps', '-gs', type=int, default=1)\nparser.add_argument('--target_update_interval', '-tu', type=int, default=10000)\nparser.add_argument('--exploration_fraction', '-e', type=float, default=.1)\nparser.add_argument('--exploration_initial_eps', '-ei', type=float, default=1.0)\nparser.add_argument('--exploration_final_eps', '-ef', type=float, default=.05)\nparser.add_argument('--max_grad_norm', '-m', type=float, default=10)\nargs = parser.parse_args()\n\n# experiment ID\nenvironment = args.environment\nn_episodes = args.episodes\nname = 'DQN-' + environment + '-' + str(n_episodes) + '-episodes'\n\nwith mlflow.start_run(run_name=name):\n\n mlflow.log_param('env', environment)\n mlflow.log_param('episodes', n_episodes)\n\n mlflow.log_param('learning_rate', args.learning_rate)\n mlflow.log_param('buffer_size', args.buffer_size)\n mlflow.log_param('learning_starts', args.learning_starts)\n mlflow.log_param('batch_size', args.batch_size)\n mlflow.log_param('tau', args.tau)\n mlflow.log_param('gamma', args.gamma)\n mlflow.log_param('train_freq', args.train_freq)\n mlflow.log_param('gradient_steps', args.gradient_steps)\n mlflow.log_param('target_update_interval', args.target_update_interval)\n mlflow.log_param('exploration_fraction', args.exploration_fraction)\n mlflow.log_param('exploration_initial_eps', args.exploration_initial_eps)\n mlflow.log_param('exploration_final_eps', args.exploration_final_eps)\n mlflow.log_param('max_grad_norm', args.max_grad_norm)\n\n env = gym.make(environment)\n env = NormalizeObservation(LoggerWrapper(env))\n\n #### TRAINING ####\n\n # Build model\n # model = DQN('MlpPolicy', env, verbose=1,\n # learning_rate=args.learning_rate,\n # buffer_size=args.buffer_size,\n # learning_starts=args.learning_starts,\n # batch_size=args.batch_size,\n # tau=args.tau,\n # gamma=args.gamma,\n # train_freq=args.train_freq,\n # gradient_steps=args.gradient_steps,\n # target_update_interval=args.target_update_interval,\n # exploration_fraction=args.exploration_fraction,\n # exploration_initial_eps=args.exploration_initial_eps,\n # exploration_final_eps=args.exploration_final_eps,\n # max_grad_norm=args.max_grad_norm,\n # tensorboard_log='./tensorboard_log/' + name)\n \n # n_timesteps_episode = env.simulator._eplus_one_epi_len / \\\n # env.simulator._eplus_run_stepsize\n # timesteps = n_episodes * n_timesteps_episode + 501\n\n # env = DummyVecEnv([lambda: env])\n # env.env_method('activate_logger')\n\n # # Callbacks\n # freq = 5 # evaluate every N episodes\n # eval_callback = LoggerEvalCallback(env, best_model_save_path='./best_models/' + name + '/',\n # log_path='./best_models/' + name + '/', eval_freq=n_timesteps_episode * freq,\n # deterministic=True, render=False, n_eval_episodes=2)\n # log_callback = LoggerCallback()\n # callback = CallbackList([log_callback, eval_callback])\n\n # # Training\n # model.learn(total_timesteps=timesteps, callback=callback)\n # model.save(name)\n\n #### LOAD MODEL ####\n\n model = DQN.load('best_models/' + name + '/best_model.zip')\n\n for i in range(n_episodes - 1):\n obs = env.reset()\n rewards = []\n done = False\n current_month = 0\n while not done:\n a, _ = model.predict(obs)\n obs, reward, done, info = env.step(a)\n rewards.append(reward)\n if info['month'] != current_month:\n current_month = info['month']\n print(info['month'], sum(rewards))\n print('Episode ', i, 'Mean reward: ', np.mean(rewards), 'Cumulative reward: ', sum(rewards))\n env.close()\n\n mlflow.log_metric('mean_reward', np.mean(rewards))\n mlflow.log_metric('cumulative_reward', sum(rewards))\n\n mlflow.end_run()" ]	[ [ "numpy.mean" ] ]
fontysrobotics/Blackboard_based_distributed_fleet_manager	[ "a6b44738fe67f4948a69f8d45da58d981c6724e0" ]	[ "catkin_ws/simulation/rviz_tools_py-master/src/rviz_tools_py/rviz_tools.py" ]	[ "#!/usr/bin/env python\n\n# Copyright (c) 2015, Carnegie Mellon University\n# All rights reserved.\n# Authors: David Butterworth <[email protected]>\n#\n# Redistribution and use in source and binary forms, with or without\n# modification, are permitted provided that the following conditions are met:\n#\n# - Redistributions of source code must retain the above copyright notice, this\n# list of conditions and the following disclaimer.\n# - Redistributions in binary form must reproduce the above copyright notice,\n# this list of conditions and the following disclaimer in the documentation\n# and/or other materials provided with the distribution.\n# - Neither the name of Carnegie Mellon University nor the names of its\n# contributors may be used to endorse or promote products derived from this\n# software without specific prior written permission.\n#\n# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n# POSSIBILITY OF SUCH DAMAGE.\n\n\n# Python includes\nimport numpy\nimport random # randint\n\n# ROS includes\nimport roslib\nimport rospy\nimport tf # tf/transformations.py\nfrom std_msgs.msg import Header, ColorRGBA\nfrom geometry_msgs.msg import Transform\nfrom geometry_msgs.msg import Pose\nfrom geometry_msgs.msg import Point, Point32\nfrom geometry_msgs.msg import Vector3\nfrom geometry_msgs.msg import Quaternion\nfrom geometry_msgs.msg import Polygon\nfrom visualization_msgs.msg import Marker\n\n\nclass RvizMarkers(object):\n \"\"\"\n A class for publishing markers in Rviz\n \"\"\"\n\n def __init__(self, base_frame, marker_topic, wait_time=None):\n self.base_frame = base_frame\n self.marker_topic = marker_topic\n\n # Set the default Marker parameters\n self.setDefaultMarkerParams()\n\n # Create the Rviz Marker Publisher\n self.loadMarkerPublisher(wait_time)\n\n\n def setDefaultMarkerParams(self):\n \"\"\"\n Set the default parameters for each type of Rviz Marker\n \"\"\"\n\n self.marker_lifetime = rospy.Duration(0.0) # 0 = Marker never expires\n self.muted = False\n self.alpha = 1.0\n\n # Set default parameters for Cylinder Marker\n self.cylinder_marker = Marker()\n self.cylinder_marker.header.frame_id = self.base_frame\n self.cylinder_marker.ns = \"Cylinder\" # unique ID\n self.cylinder_marker.action = Marker().ADD\n self.cylinder_marker.type = Marker().CYLINDER\n self.cylinder_marker.lifetime = self.marker_lifetime\n\n # Reset Marker\n self.reset_marker = Marker()\n self.reset_marker.header.frame_id = self.base_frame\n self.reset_marker.header.stamp = rospy.Time()\n self.reset_marker.action = 3\n\n # Arrow Marker\n self.arrow_marker = Marker()\n self.arrow_marker.header.frame_id = self.base_frame\n self.arrow_marker.ns = \"Arrow\" # unique ID\n self.arrow_marker.action = Marker().ADD\n self.arrow_marker.type = Marker().ARROW\n self.arrow_marker.lifetime = self.marker_lifetime\n\n # Rectangle Marker\n self.rectangle_marker = Marker()\n self.rectangle_marker.header.frame_id = self.base_frame\n self.rectangle_marker.ns = \"Rectangle\" # unique ID\n self.rectangle_marker.action = Marker().ADD\n self.rectangle_marker.type = Marker().CUBE\n self.rectangle_marker.lifetime = self.marker_lifetime\n\n # Line Marker\n self.line_marker = Marker()\n self.line_marker.header.frame_id = self.base_frame\n self.line_marker.ns = \"Line\" # unique ID\n self.line_marker.action = Marker().ADD\n self.line_marker.type = Marker().LINE_STRIP\n self.line_marker.lifetime = self.marker_lifetime\n\n # Path Marker (Line List)\n self.path_marker = Marker()\n self.path_marker.header.frame_id = self.base_frame\n self.path_marker.ns = \"Path\" # unique ID\n self.path_marker.action = Marker().ADD\n self.path_marker.type = Marker().LINE_LIST\n self.path_marker.lifetime = self.marker_lifetime\n self.path_marker.pose.position.x = 0.0\n self.path_marker.pose.position.y = 0.0\n self.path_marker.pose.position.z = 0.0\n self.path_marker.pose.orientation.x = 0.0\n self.path_marker.pose.orientation.y = 0.0\n self.path_marker.pose.orientation.z = 0.0\n self.path_marker.pose.orientation.w = 1.0\n\n # Sphere Marker (A single sphere)\n # This renders a low-quality sphere\n self.sphere_marker = Marker()\n self.sphere_marker.header.frame_id = self.base_frame\n self.sphere_marker.ns = \"Sphere\" # unique ID\n self.sphere_marker.type = Marker().SPHERE\n self.sphere_marker.action = Marker().ADD\n self.sphere_marker.lifetime = self.marker_lifetime\n self.sphere_marker.pose.position.x = 0\n self.sphere_marker.pose.position.y = 0\n self.sphere_marker.pose.position.z = 0\n self.sphere_marker.pose.orientation.x = 0.0\n self.sphere_marker.pose.orientation.y = 0.0\n self.sphere_marker.pose.orientation.z = 0.0\n self.sphere_marker.pose.orientation.w = 1.0\n\n # Sphere Marker #2 (A single sphere)\n # A Sphere List with one sphere, this renders a\n # higher-quality sphere than the method above\n self.sphere_marker2 = Marker()\n self.sphere_marker2.header.frame_id = self.base_frame\n self.sphere_marker2.ns = \"Sphere\" # unique ID\n self.sphere_marker2.type = Marker().SPHERE_LIST\n self.sphere_marker2.action = Marker().ADD\n self.sphere_marker2.lifetime = self.marker_lifetime\n self.sphere_marker2.pose.position.x = 0\n self.sphere_marker2.pose.position.y = 0\n self.sphere_marker2.pose.position.z = 0\n self.sphere_marker2.pose.orientation.x = 0.0\n self.sphere_marker2.pose.orientation.y = 0.0\n self.sphere_marker2.pose.orientation.z = 0.0\n self.sphere_marker2.pose.orientation.w = 1.0\n point1 = Point()\n self.sphere_marker2.points.append(point1)\n self.sphere_marker2.colors.append(self.getColor('blue'))\n\n # Spheres List (Multiple spheres)\n self.spheres_marker = Marker()\n self.spheres_marker.header.frame_id = self.base_frame\n self.spheres_marker.ns = \"Spheres\" # unique ID\n self.spheres_marker.type = Marker().SPHERE_LIST\n self.spheres_marker.action = Marker().ADD\n self.spheres_marker.lifetime = self.marker_lifetime\n self.spheres_marker.pose.position.x = 0.0\n self.spheres_marker.pose.position.y = 0.0\n self.spheres_marker.pose.position.z = 0.0\n self.spheres_marker.pose.orientation.x = 0.0\n self.spheres_marker.pose.orientation.y = 0.0\n self.spheres_marker.pose.orientation.z = 0.0\n self.spheres_marker.pose.orientation.w = 1.0\n\n # Cube Marker (Block or cuboid)\n self.cube_marker = Marker()\n self.cube_marker.header.frame_id = self.base_frame\n self.cube_marker.ns = \"Block\" # unique ID\n self.cube_marker.action = Marker().ADD\n self.cube_marker.type = Marker().CUBE\n self.cube_marker.lifetime = self.marker_lifetime\n\n # Cubes List (Multiple cubes)\n self.cubes_marker = Marker()\n self.cubes_marker.header.frame_id = self.base_frame\n self.cubes_marker.ns = \"Cubes\" # unique ID\n self.cubes_marker.type = Marker().CUBE_LIST\n self.cubes_marker.action = Marker().ADD\n self.cubes_marker.lifetime = self.marker_lifetime\n self.cubes_marker.pose.position.x = 0.0\n self.cubes_marker.pose.position.y = 0.0\n self.cubes_marker.pose.position.z = 0.0\n self.cubes_marker.pose.orientation.x = 0.0\n self.cubes_marker.pose.orientation.y = 0.0\n self.cubes_marker.pose.orientation.z = 0.0\n self.cubes_marker.pose.orientation.w = 1.0\n\n # Cylinder Marker\n self.cylinder_marker = Marker()\n self.cylinder_marker.header.frame_id = self.base_frame\n self.cylinder_marker.ns = \"Cylinder\" # unique ID\n self.cylinder_marker.action = Marker().ADD\n self.cylinder_marker.type = Marker().CYLINDER\n self.cylinder_marker.lifetime = self.marker_lifetime\n\n # Mesh Marker\n self.mesh_marker = Marker()\n self.mesh_marker.header.frame_id = self.base_frame\n self.mesh_marker.ns = \"Mesh\" # unique ID\n self.mesh_marker.action = Marker().ADD\n self.mesh_marker.type = Marker().MESH_RESOURCE\n self.mesh_marker.lifetime = self.marker_lifetime\n\n # Text Marker\n self.text_marker = Marker()\n self.text_marker.header.frame_id = self.base_frame\n self.text_marker.ns = \"Text\" # unique ID\n self.text_marker.action = Marker().ADD\n self.text_marker.type = Marker().TEXT_VIEW_FACING\n self.text_marker.lifetime = self.marker_lifetime\n\n\n def loadMarkerPublisher(self, wait_time=None):\n \"\"\"\n Initialize the ROS Publisher.\n\n If wait_time != None, wait for specified number of\n seconds for a subscriber to connect.\n \"\"\"\n\n # Check if the ROS Publisher has already been created\n if hasattr(self, 'pub_rviz_marker'):\n return\n\n # Create the Rviz Marker Publisher\n self.pub_rviz_marker = rospy.Publisher(self.marker_topic, Marker, queue_size=10)\n rospy.logdebug(\"Publishing Rviz markers on topic '%s'\", self.marker_topic)\n\n # Block for specified number of seconds,\n # or until there is 1 subscriber\n if wait_time != None:\n self.waitForSubscriber(self.pub_rviz_marker, wait_time)\n\n\n def waitForSubscriber(self, publisher, wait_time=1.0):\n \"\"\"\n Wait until there is 1 subscriber to a ROS Publisher,\n or until some number of seconds have elapsed.\n \"\"\"\n\n start_time = rospy.Time.now()\n max_time = start_time + rospy.Duration(wait_time)\n\n num_existing_subscribers = publisher.get_num_connections()\n\n while (num_existing_subscribers == 0):\n #print 'Number of subscribers: ', num_existing_subscribers\n rospy.Rate(100).sleep()\n\n if (rospy.Time.now() > max_time):\n rospy.logerr(\"No subscribers connected to the '%s' topic after %f seconds\", self.marker_topic, wait_time)\n return False\n\n num_existing_subscribers = publisher.get_num_connections()\n\n return True\n\n\n def publishMarker(self, marker):\n \"\"\"\n Publish a Marker Msg\n \"\"\"\n\n if (self.muted == True):\n return True\n\n ## Check ROS Publisher\n #self.loadMarkerPublisher()\n\n self.pub_rviz_marker.publish(marker)\n\n return True\n\n\n def deleteAllMarkers(self):\n \"\"\"\n Publish a Msg to delete all Markers\n \"\"\"\n\n return self.publishMarker(self.reset_marker)\n\n\n def getColor(self, color):\n \"\"\"\n Convert a color name or RGB value to a ROS ColorRGBA type\n\n @param color name (string) or RGB color value (tuple or list)\n\n @return color (ColorRGBA)\n \"\"\"\n\n result = ColorRGBA()\n result.a = self.alpha\n\n if (type(color) == tuple) or (type(color) == list):\n if len(color) == 3:\n result.r = color[0]\n result.g = color[1]\n result.b = color[2]\n elif len(color) == 4:\n result.r = color[0]\n result.g = color[1]\n result.b = color[2]\n result.a = color[3]\n else:\n raise ValueError('color must have 3 or 4 float values in getColor()')\n elif (color == 'red'):\n result.r = 0.8\n result.g = 0.1\n result.b = 0.1\n elif (color == 'green'):\n result.r = 0.1\n result.g = 0.8\n result.b = 0.1\n elif (color == 'blue'):\n result.r = 0.1\n result.g = 0.1\n result.b = 0.8\n elif (color == 'grey') or (color == 'gray'):\n result.r = 0.9\n result.g = 0.9\n result.b = 0.9\n elif (color == 'white'):\n result.r = 1.0\n result.g = 1.0\n result.b = 1.0\n elif (color == 'orange'):\n result.r = 1.0\n result.g = 0.5\n result.b = 0.0\n elif (color == 'translucent_light'):\n result.r = 0.1\n result.g = 0.1\n result.b = 0.1\n result.a = 0.1\n elif (color == 'translucent'):\n result.r = 0.1\n result.g = 0.1\n result.b = 0.1\n result.a = 0.25\n elif (color == 'translucent_dark'):\n result.r = 0.1\n result.g = 0.1\n result.b = 0.1\n result.a = 0.5\n elif (color == 'black'):\n result.r = 0.0\n result.g = 0.0\n result.b = 0.0\n elif (color == 'yellow'):\n result.r = 1.0\n result.g = 1.0\n result.b = 0.0\n elif (color == 'brown'):\n result.r = 0.597\n result.g = 0.296\n result.b = 0.0\n elif (color == 'pink'):\n result.r = 1.0\n result.g = 0.4\n result.b = 1\n elif (color == 'lime_green'):\n result.r = 0.6\n result.g = 1.0\n result.b = 0.2\n elif (color == 'clear'):\n result.r=1.0\n result.g=1.0\n result.b=1.0\n result.a=0.0\n elif (color == 'purple'):\n result.r = 0.597\n result.g = 0.0\n result.b = 0.597\n elif (color == 'random'):\n # Get a random color that is not too light\n while True:\n result.r = random.random() # random float from 0 to 1\n result.g = random.random()\n result.b = random.random()\n if ((result.r + result.g + result.b) > 1.5): # 0=black, 3=white\n break\n else:\n rospy.logerr(\"getColor() called with unknown color name '%s', defaulting to 'blue'\", color)\n result.r = 0.1\n result.g = 0.1\n result.b = 0.8\n\n return result \n\n\n def getRandomColor(self):\n \"\"\"\n Get a random color.\n\n @return color (ColorRGBA)\n \"\"\"\n\n # Make a list of the color names to choose from\n all_colors = []\n all_colors.append('red')\n all_colors.append('green')\n all_colors.append('blue')\n all_colors.append('grey')\n all_colors.append('white')\n all_colors.append('orange')\n all_colors.append('yellow')\n all_colors.append('brown')\n all_colors.append('pink')\n all_colors.append('lime_green')\n all_colors.append('purple')\n\n # Chose a random color name\n rand_num = random.randint(0, len(all_colors) - 1)\n rand_color_name = all_colors[rand_num]\n\n return rand_color_name\n\n\n def publishSphere(self, pose, color, scale, lifetime=None):\n \"\"\"\n Publish a sphere Marker. This renders 3D looking sphere.\n\n @param pose (numpy matrix, numpy ndarray, ROS Pose)\n @param color name (string) or RGB color value (tuple or list)\n @param scale (ROS Vector3, float)\n @param lifetime (float, None = never expire)\n \"\"\"\n\n if (self.muted == True):\n return True\n\n # Convert input pose to a ROS Pose Msg\n if (type(pose) == numpy.matrix) or (type(pose) == numpy.ndarray):\n sphere_pose = mat_to_pose(pose)\n elif type(pose) == Pose:\n sphere_pose = pose\n elif type(pose) == Point:\n pose_msg = Pose()\n pose_msg.position = pose\n sphere_pose = pose_msg\n else:\n rospy.logerr(\"Pose is unsupported type '%s' in publishSphere()\", type(pose).__name__)\n return False\n\n # Convert input scale to a ROS Vector3 Msg\n if type(scale) == Vector3:\n sphere_scale = scale\n elif type(scale) == float:\n sphere_scale = Vector3(scale, scale, scale)\n else:\n rospy.logerr(\"Scale is unsupported type '%s' in publishSphere()\", type(scale).__name__)\n return False\n\n # Increment the ID number\n self.sphere_marker.id += 1\n\n # Get the default parameters\n sphere_marker = self.sphere_marker\n\n if lifetime == None:\n sphere_marker.lifetime = rospy.Duration(0.0) # 0 = Marker never expires\n else:\n sphere_marker.lifetime = rospy.Duration(lifetime) # in seconds\n\n # Set the timestamp\n sphere_marker.header.stamp = rospy.Time.now()\n\n # Set marker size\n sphere_marker.scale = sphere_scale\n\n # Set marker color\n sphere_marker.color = self.getColor(color)\n\n # Set the pose\n sphere_marker.pose = sphere_pose\n\n return self.publishMarker(sphere_marker)\n\n\n def publishSphere2(self, pose, color, scale, lifetime=None):\n \"\"\"\n Publish a sphere Marker. This renders a smoother, flatter-looking sphere.\n\n @param pose (numpy matrix, numpy ndarray, ROS Pose)\n @param color name (string) or RGB color value (tuple or list)\n @param scale (ROS Vector3, float)\n @param lifetime (float, None = never expire)\n \"\"\"\n\n if (self.muted == True):\n return True\n\n # Convert input pose to a ROS Pose Msg\n if (type(pose) == numpy.matrix) or (type(pose) == numpy.ndarray):\n sphere_pose = mat_to_pose(pose)\n elif type(pose) == Pose:\n sphere_pose = pose\n elif type(pose) == Point:\n pose_msg = Pose()\n pose_msg.position = pose\n sphere_pose = pose_msg\n else:\n rospy.logerr(\"Pose is unsupported type '%s' in publishSphere()\", type(pose).__name__)\n return False\n\n # Convert input scale to a ROS Vector3 Msg\n if type(scale) == Vector3:\n sphere_scale = scale\n elif type(scale) == float:\n sphere_scale = Vector3(scale, scale, scale)\n else:\n rospy.logerr(\"Scale is unsupported type '%s' in publishSphere()\", type(scale).__name__)\n return False\n\n # Increment the ID number\n self.sphere_marker.id += 1\n\n # Get the default parameters\n sphere_marker = self.sphere_marker2 # sphere_marker2 = SPHERE_LIST\n\n if lifetime == None:\n sphere_marker.lifetime = rospy.Duration(0.0) # 0 = Marker never expires\n else:\n sphere_marker.lifetime = rospy.Duration(lifetime) # in seconds\n\n # Set the timestamp\n sphere_marker.header.stamp = rospy.Time.now()\n\n # Set marker size\n sphere_marker.scale = sphere_scale\n\n # Set marker color\n sphere_marker.color = self.getColor(color)\n\n # Set the pose of one sphere in the list\n sphere_marker.points[0] = sphere_pose.position\n sphere_marker.colors[0] = self.getColor(color)\n\n return self.publishMarker(sphere_marker)\n\n\n def publishArrow(self, pose, color, scale, lifetime=None):\n \"\"\"\n Publish an arrow Marker.\n\n @param pose (numpy matrix, numpy ndarray, ROS Pose)\n @param color name (string) or RGB color value (tuple or list)\n @param scale (ROS Vector3, float)\n @param lifetime (float, None = never expire)\n \"\"\"\n\n if (self.muted == True):\n return True\n\n # Convert input pose to a ROS Pose Msg\n if (type(pose) == numpy.matrix) or (type(pose) == numpy.ndarray):\n arrow_pose = mat_to_pose(pose)\n elif type(pose) == Pose:\n arrow_pose = pose\n else:\n rospy.logerr(\"Pose is unsupported type '%s' in publishArrow()\", type(pose).__name__)\n return False\n\n # Convert input scale to a ROS Vector3 Msg\n if type(scale) == Vector3:\n arrow_scale = scale\n elif type(scale) == float:\n arrow_scale = Vector3(scale, 0.1scale, 0.1scale)\n else:\n rospy.logerr(\"Scale is unsupported type '%s' in publishArrow()\", type(scale).__name__)\n return False\n\n # Increment the ID number\n self.arrow_marker.id += 1\n\n # Get the default parameters\n arrow_marker = self.arrow_marker\n\n if lifetime == None:\n arrow_marker.lifetime = rospy.Duration(0.0) # 0 = Marker never expires\n else:\n arrow_marker.lifetime = rospy.Duration(lifetime) # in seconds\n\n # Set the timestamp\n arrow_marker.header.stamp = rospy.Time.now()\n\n # Set the pose\n arrow_marker.pose = arrow_pose\n\n # Set marker size\n arrow_marker.scale = arrow_scale\n\n # Set marker color\n arrow_marker.color = self.getColor(color)\n\n return self.publishMarker(arrow_marker)\n\n\n def publishCube(self, pose, color, scale, lifetime=None):\n \"\"\"\n Publish a cube Marker.\n\n @param pose (numpy matrix, numpy ndarray, ROS Pose)\n @param color name (string) or RGB color value (tuple or list)\n @param scale (ROS Vector3, float)\n @param lifetime (float, None = never expire)\n \"\"\"\n\n if (self.muted == True):\n return True\n\n # Convert input pose to a ROS Pose Msg\n if (type(pose) == numpy.matrix) or (type(pose) == numpy.ndarray):\n cube_pose = mat_to_pose(pose)\n elif type(pose) == Pose:\n cube_pose = pose\n else:\n rospy.logerr(\"Pose is unsupported type '%s' in publishCube()\", type(pose).__name__)\n return False\n\n # Convert input scale to a ROS Vector3 Msg\n if type(scale) == Vector3:\n cube_scale = scale\n elif type(scale) == float:\n cube_scale = Vector3(scale, scale, scale)\n else:\n rospy.logerr(\"Scale is unsupported type '%s' in publishCube()\", type(scale).__name__)\n return False\n\n # Increment the ID number\n self.cube_marker.id += 1\n\n # Get the default parameters\n cube_marker = self.cube_marker\n\n if lifetime == None:\n cube_marker.lifetime = rospy.Duration(0.0) # 0 = Marker never expires\n else:\n cube_marker.lifetime = rospy.Duration(lifetime) # in seconds\n\n # Set the timestamp\n cube_marker.header.stamp = rospy.Time.now()\n\n # Set the pose\n cube_marker.pose = cube_pose\n\n # Set marker size\n cube_marker.scale = cube_scale\n\n # Set marker color\n cube_marker.color = self.getColor(color)\n\n return self.publishMarker(cube_marker)\n\n\n def publishCubes(self, list_of_cubes, color, scale, lifetime=None):\n \"\"\"\n Publish a list of cubes.\n\n @param list_of_cubes (list of numpy matrix, list of numpy ndarray, list of ROS Pose)\n @param color name (string) or RGB color value (tuple or list)\n @param scale (ROS Vector3, float)\n @param lifetime (float, None = never expire)\n \"\"\"\n\n if (self.muted == True):\n return True\n\n # Check input\n if type(list_of_cubes) != list:\n rospy.logerr(\"list_of_cubes is unsupported type '%s' in publishCubes()\", type(list_of_cubes).__name__)\n return False\n\n # Convert input scale to a ROS Vector3 Msg\n if type(scale) == Vector3:\n cubes_scale = scale\n elif type(scale) == float:\n cubes_scale = Vector3(scale, scale, scale)\n else:\n rospy.logerr(\"Scale is unsupported type '%s' in publishCubes()\", type(scale).__name__)\n return False\n\n # Increment the ID number\n self.cubes_marker.id += 1\n\n # Get the default parameters\n cubes_marker = self.cubes_marker\n\n if lifetime == None:\n cubes_marker.lifetime = rospy.Duration(0.0) # 0 = Marker never expires\n else:\n cubes_marker.lifetime = rospy.Duration(lifetime) # in seconds\n\n # Set the timestamp\n cubes_marker.header.stamp = rospy.Time.now()\n\n # Set marker size\n cubes_marker.scale = cubes_scale\n\n # Set marker color\n cubes_marker.color = self.getColor(color)\n\n cubes_color = self.getColor(color)\n\n # Set the cubes positions and color\n cubes_marker.points[:] = [] # clear\n cubes_marker.colors[:] = []\n for i in range(0, len(list_of_cubes)):\n\n # Each cube position needs to be a ROS Point Msg\n if type(list_of_cubes[i]) == Pose:\n cubes_marker.points.append(list_of_cubes[i].position)\n cubes_marker.colors.append(cubes_color)\n elif (type(list_of_cubes[i]) == numpy.matrix) or (type(list_of_cubes[i]) == numpy.ndarray):\n pose_i = mat_to_pose(list_of_cubes[i])\n cubes_marker.points.append(pose_i.position)\n cubes_marker.colors.append(cubes_color)\n elif type(list_of_cubes[i]) == Point:\n cubes_marker.points.append(list_of_cubes[i])\n cubes_marker.colors.append(cubes_color)\n else:\n rospy.logerr(\"list_of_cubes contains unsupported type '%s' in publishCubes()\", type(list_of_cubes[i]).__name__)\n return False\n\n return self.publishMarker(cubes_marker)\n\n\n def publishBlock(self, pose, color, scale, lifetime=None):\n \"\"\"\n Publish a cube Marker.\n\n @param pose (numpy matrix, numpy ndarray, ROS Pose)\n @param color name (string) or RGB color value (tuple or list)\n @param scale (ROS Vector3, float)\n @param lifetime (float, None = never expire)\n \"\"\"\n\n return self.publishCube(pose, color, scale)\n\n\n def publishCylinder(self, pose, color, height, radius, lifetime=None):\n \"\"\"\n Publish a cylinder Marker.\n\n @param pose (numpy matrix, numpy ndarray, ROS Pose)\n @param color name (string) or RGB color value (tuple or list)\n @param height (float)\n @param radius (float)\n @param lifetime (float, None = never expire)\n \"\"\"\n\n if (self.muted == True):\n return True\n\n # Convert input pose to a ROS Pose Msg\n if (type(pose) == numpy.matrix) or (type(pose) == numpy.ndarray):\n cylinder_pose = mat_to_pose(pose)\n elif type(pose) == Pose:\n cylinder_pose = pose\n else:\n rospy.logerr(\"Pose is unsupported type '%s' in publishCylinder()\", type(pose).__name__)\n return False\n\n # Increment the ID number\n self.cylinder_marker.id += 1\n\n # Get the default parameters\n cylinder_marker = self.cylinder_marker\n\n if lifetime == None:\n cylinder_marker.lifetime = rospy.Duration(0.0) # 0 = Marker never expires\n else:\n cylinder_marker.lifetime = rospy.Duration(lifetime) # in seconds\n\n # Set the timestamp\n cylinder_marker.header.stamp = rospy.Time.now()\n\n # Set the pose\n cylinder_marker.pose = cylinder_pose\n\n # Set marker size\n cylinder_marker.scale.x = radius\n cylinder_marker.scale.y = radius\n cylinder_marker.scale.z = height\n\n # Set marker color\n cylinder_marker.color = self.getColor(color)\n\n return self.publishMarker(cylinder_marker)\n\n\n def publishAxis(self, pose, length, radius, lifetime=None):\n \"\"\"\n Publish an axis Marker.\n\n @param pose (numpy matrix, numpy ndarray, ROS Pose)\n @param length axis length (float)\n @param radius axis radius (float)\n @param lifetime (float, None = never expire)\n \"\"\"\n\n # Convert input pose to a numpy matrix\n if (type(pose) == numpy.matrix) or (type(pose) == numpy.ndarray):\n axis_pose = pose\n elif type(pose) == Pose:\n axis_pose = pose_to_mat(pose)\n else:\n rospy.logerr(\"Pose is unsupported type '%s' in publishAxis()\", type(pose).__name__)\n return False\n\n t = tf.transformations.translation_matrix( (length/2.0, 0.0, 0.0) )\n r = tf.transformations.rotation_matrix(numpy.pi/2.0, (0,1,0))\n m = tf.transformations.concatenate_matrices(axis_pose, t, r)\n x_pose = mat_to_pose(m)\n self.publishCylinder(x_pose, 'red', length, radius, lifetime)\n\n t = tf.transformations.translation_matrix( (0.0, length/2.0, 0.0) )\n r = tf.transformations.rotation_matrix(numpy.pi/2.0, (1,0,0))\n m = tf.transformations.concatenate_matrices(axis_pose, t, r)\n y_pose = mat_to_pose(m)\n self.publishCylinder(y_pose, 'green', length, radius, lifetime)\n\n t = tf.transformations.translation_matrix( (0.0, 0.0, length/2.0) )\n r = tf.transformations.rotation_matrix(0.0, (0,0,1))\n m = tf.transformations.concatenate_matrices(axis_pose, t, r)\n z_pose = mat_to_pose(m)\n self.publishCylinder(z_pose, 'blue', length, radius, lifetime)\n\n return True\n\n\n def publishMesh(self, pose, file_name, color, scale, lifetime=None):\n \"\"\"\n Publish a mesh Marker. The mesh file can be a binary STL or collada DAE file.\n\n @param pose (numpy matrix, numpy ndarray, ROS Pose)\n @param file_name (string)\n @param color name (string) or RGB color value (tuple or list)\n @param scale (ROS Vector3, float)\n @param lifetime (float, None = never expire)\n \"\"\"\n\n if (self.muted == True):\n return True\n\n # Convert input pose to a ROS Pose Msg\n if (type(pose) == numpy.matrix) or (type(pose) == numpy.ndarray):\n mesh_pose = mat_to_pose(pose)\n elif type(pose) == Pose:\n mesh_pose = pose\n else:\n rospy.logerr(\"Pose is unsupported type '%s' in publishMesh()\", type(pose).__name__)\n return False\n\n # Convert input scale to a ROS Vector3 Msg\n if type(scale) == Vector3:\n mesh_scale = scale\n elif type(scale) == float:\n mesh_scale = Vector3(scale, scale, scale)\n else:\n rospy.logerr(\"Scale is unsupported type '%s' in publishMesh()\", type(scale).__name__)\n return False\n\n # Increment the ID number\n self.mesh_marker.id += 1\n\n # Get the default parameters\n mesh_marker = self.mesh_marker\n\n if lifetime == None:\n mesh_marker.lifetime = rospy.Duration(0.0) # 0 = Marker never expires\n else:\n mesh_marker.lifetime = rospy.Duration(lifetime) # in seconds\n\n # Set the timestamp\n mesh_marker.header.stamp = rospy.Time.now()\n\n # Set marker size\n mesh_marker.scale = mesh_scale\n\n # Set marker color\n if color == None:\n mesh_marker.color = ColorRGBA() # no color\n else:\n mesh_marker.color = self.getColor(color)\n\n # Set the pose\n mesh_marker.pose = mesh_pose\n\n # Set the mesh\n mesh_marker.mesh_resource = file_name\n mesh_marker.mesh_use_embedded_materials = True\n\n return self.publishMarker(mesh_marker)\n\n\n def publishRectangle(self, point1, point2, color, lifetime=None):\n \"\"\"\n Publish a rectangle Marker between two points. If the z-values are not the same then this will result in a cuboid.\n\n @param point1 (ROS Point)\n @param point2 (ROS Point)\n @param color name (string) or RGB color value (tuple or list)\n @param lifetime (float, None = never expire)\n \"\"\"\n\n if (self.muted == True):\n return True\n\n # Convert input points to ROS Point Msgs\n if type(point1) == Point:\n rect_point1 = point1\n else:\n rospy.logerr(\"Point1 is unsupported type '%s' in publishRectangle()\", type(point1).__name__)\n return False\n if type(point2) == Point:\n rect_point2 = point2\n else:\n rospy.logerr(\"Point2 is unsupported type '%s' in publishRectangle()\", type(point2).__name__)\n return False\n\n # Increment the ID number\n self.rectangle_marker.id += 1\n\n # Get the default parameters\n rectangle_marker = self.rectangle_marker\n\n if lifetime == None:\n rectangle_marker.lifetime = rospy.Duration(0.0) # 0 = Marker never expires\n else:\n rectangle_marker.lifetime = rospy.Duration(lifetime) # in seconds\n\n # Set the timestamp\n rectangle_marker.header.stamp = rospy.Time.now()\n\n # Set marker color\n rectangle_marker.color = self.getColor(color)\n\n # Calculate the center pose\n rect_pose = Pose()\n rect_pose.position.x = (rect_point1.x - rect_point2.x) / 2.0 + rect_point2.x\n rect_pose.position.y = (rect_point1.y - rect_point2.y) / 2.0 + rect_point2.y\n rect_pose.position.z = (rect_point1.z - rect_point2.z) / 2.0 + rect_point2.z\n rectangle_marker.pose = rect_pose\n\n # Calculate scale\n rectangle_marker.scale.x = numpy.fabs(rect_point1.x - rect_point2.x)\n rectangle_marker.scale.y = numpy.fabs(rect_point1.y - rect_point2.y)\n rectangle_marker.scale.z = numpy.fabs(rect_point1.z - rect_point2.z)\n\n return self.publishMarker(rectangle_marker)\n\n\n def publishPlane(self, pose, depth, width, color, lifetime=None):\n \"\"\"\n Publish a plane Marker.\n\n @param pose (numpy matrix, numpy ndarray, ROS Pose)\n @param depth (float)\n @param width (float)\n @param color name (string) or RGB color value (tuple or list)\n @param lifetime (float, None = never expire)\n \"\"\"\n\n if (self.muted == True):\n return True\n\n # Convert input pose to a ROS Pose Msg\n if (type(pose) == numpy.matrix) or (type(pose) == numpy.ndarray):\n rect_pose = mat_to_pose(pose)\n elif type(pose) == Pose:\n rect_pose = pose\n else:\n rospy.logerr(\"Pose is unsupported type '%s' in publishRectangle()\", type(pose).__name__)\n return False\n\n # Increment the ID number\n self.rectangle_marker.id += 1\n\n # Get the default parameters\n rectangle_marker = self.rectangle_marker\n\n if lifetime == None:\n rectangle_marker.lifetime = rospy.Duration(0.0) # 0 = Marker never expires\n else:\n rectangle_marker.lifetime = rospy.Duration(lifetime) # in seconds\n\n # Set the timestamp\n rectangle_marker.header.stamp = rospy.Time.now()\n\n # Set marker color\n rectangle_marker.color = self.getColor(color)\n\n # Set the pose\n rectangle_marker.pose = rect_pose\n\n # Set the scale\n rectangle_marker.scale.x = depth\n rectangle_marker.scale.y = width\n rectangle_marker.scale.z = 0.0\n\n return self.publishMarker(rectangle_marker)\n\n\n def publishLine(self, point1, point2, color, width, lifetime=None):\n \"\"\"\n Publish a line Marker between two points.\n\n @param point1 (ROS Point, ROS Pose, numpy matrix, numpy ndarray)\n @param point2 (ROS Point, ROS Pose, numpy matrix, numpy ndarray)\n @param color name (string) or RGB color value (tuple or list)\n @param width (float)\n @param lifetime (float, None = never expire)\n \"\"\"\n\n if (self.muted == True):\n return True\n\n # Convert input points to ROS Point Msgs\n if type(point1) == Point:\n line_point1 = point1\n elif type(point1) == Pose:\n position = point1.position\n line_point1 = Point(position.x, position.y, position.z)\n elif (type(point1) == numpy.matrix) or (type(point1) == numpy.ndarray):\n pose = mat_to_pose(point1)\n position = pose.position\n line_point1 = Point(position.x, position.y, position.z)\n else:\n rospy.logerr(\"Point1 is unsupported type '%s' in publishLine()\", type(point1).__name__)\n return False\n\n if type(point2) == Point:\n line_point2 = point2\n elif type(point2) == Pose:\n position = point2.position\n line_point2 = Point(position.x, position.y, position.z)\n elif (type(point2) == numpy.matrix) or (type(point2) == numpy.ndarray):\n pose = mat_to_pose(point2)\n position = pose.position\n line_point2 = Point(position.x, position.y, position.z)\n else:\n rospy.logerr(\"Point2 is unsupported type '%s' in publishLine()\", type(point2).__name__)\n return False\n\n # Increment the ID number\n self.line_marker.id += 1\n\n # Get the default parameters\n line_marker = self.line_marker\n\n if lifetime == None:\n line_marker.lifetime = rospy.Duration(0.0) # 0 = Marker never expires\n else:\n line_marker.lifetime = rospy.Duration(lifetime) # in seconds\n\n # Set the timestamp\n line_marker.header.stamp = rospy.Time.now()\n\n # Set marker color\n line_marker.color = self.getColor(color)\n\n # Set the start and end points\n line_marker.points[:] = [] # clear\n line_marker.points.append(line_point1)\n line_marker.points.append(line_point2)\n\n # Set the line width\n line_marker.scale.x = width\n\n return self.publishMarker(line_marker)\n\n\n def publishPath(self, path, color, width, lifetime=None):\n \"\"\"\n Publish a path Marker using a set of waypoints.\n\n @param path (list of ROS Points)\n @param color name (string) or RGB color value (tuple or list)\n @param width (float)\n @param lifetime (float, None = never expire)\n \"\"\"\n\n if (self.muted == True):\n return True\n\n # Check input\n if type(path) == list:\n path_path = path # :-)\n else:\n rospy.logerr(\"Path is unsupported type '%s' in publishPath()\", type(path).__name__)\n return False\n\n # Increment the ID number\n self.path_marker.id += 1\n\n # Get the default parameters\n path_marker = self.path_marker\n\n if lifetime == None:\n path_marker.lifetime = rospy.Duration(0.0) # 0 = Marker never expires\n else:\n path_marker.lifetime = rospy.Duration(lifetime) # in seconds\n\n # Set the timestamp\n path_marker.header.stamp = rospy.Time.now()\n\n # Set the path width\n path_marker.scale.x = width\n\n path_color = self.getColor(color)\n\n # Set the path points and color\n path_marker.points[:] = [] # clear\n path_marker.colors[:] = []\n for i in range(1, len(path)):\n\n # Each path waypoint needs to be a ROS Point Msg\n if type(path[i]) == Point:\n # Start of segment is previous point\n path_marker.points.append(path[i-1])\n path_marker.colors.append(path_color)\n # End of segment is current point\n path_marker.points.append(path[i])\n path_marker.colors.append(path_color)\n elif type(path[i]) == Pose:\n # Start of segment is previous point\n position = path[i-1].position\n point = Point(position.x, position.y, position.z)\n path_marker.points.append(point)\n path_marker.colors.append(path_color)\n # End of segment is current point\n position = path[i].position\n point = Point(position.x, position.y, position.z)\n path_marker.points.append(point)\n path_marker.colors.append(path_color)\n elif (type(path[i]) == numpy.matrix) or (type(path[i]) == numpy.ndarray):\n # Start of segment is previous point\n pose = mat_to_pose(path[i-1])\n position = pose.position\n point = Point(position.x, position.y, position.z)\n path_marker.points.append(point)\n path_marker.colors.append(path_color)\n # End of segment is current point\n pose = mat_to_pose(path[i])\n position = pose.position\n point = Point(position.x, position.y, position.z)\n path_marker.points.append(point)\n path_marker.colors.append(path_color) \n else:\n rospy.logerr(\"path list contains unsupported type '%s' in publishPath()\", type(path[i]).__name__)\n return False\n\n return self.publishMarker(path_marker)\n\n\n def publishPolygon(self, polygon, color, width, lifetime=None):\n \"\"\"\n Publish a polygon Marker.\n\n @param polygon (ROS Polygon)\n @param color name (string) or RGB color value (tuple or list)\n @param width line width (float)\n @param lifetime (float, None = never expire)\n\n a path with the start and end points connected\n \"\"\"\n\n if (self.muted == True):\n return True\n\n # Check input\n if type(polygon) == Polygon:\n polygon_msg = polygon\n else:\n rospy.logerr(\"Path is unsupported type '%s' in publishPolygon()\", type(polygon).__name__)\n return False\n\n # Copy points from ROS Polygon Msg into a list\n polygon_path = []\n for i in range(0, len(polygon_msg.points)):\n x = polygon_msg.points[i].x\n y = polygon_msg.points[i].y\n z = polygon_msg.points[i].z\n polygon_path.append( Point(x,y,z) )\n\n # Add the first point again\n x = polygon_msg.points[0].x\n y = polygon_msg.points[0].y\n z = polygon_msg.points[0].z\n polygon_path.append( Point(x,y,z) )\n\n return self.publishPath(polygon_path, color, width, lifetime)\n\n\n def publishSpheres(self, list_of_spheres, color, scale, lifetime=None):\n \"\"\"\n Publish a list of spheres. This renders smoother, flatter-looking spheres.\n\n @param list_of_spheres (list of numpy matrix, list of numpy ndarray, list of ROS Pose)\n @param color name (string) or RGB color value (tuple or list)\n @param scale (ROS Vector3, float)\n @param lifetime (float, None = never expire)\n \"\"\"\n\n if (self.muted == True):\n return True\n\n # Check input\n if type(list_of_spheres) != list:\n rospy.logerr(\"list_of_spheres is unsupported type '%s' in publishSpheres()\", type(list_of_spheres).__name__)\n return False\n\n # Convert input scale to a ROS Vector3 Msg\n if type(scale) == Vector3:\n spheres_scale = scale\n elif type(scale) == float:\n spheres_scale = Vector3(scale, scale, scale)\n else:\n rospy.logerr(\"Scale is unsupported type '%s' in publishSpheres()\", type(scale).__name__)\n return False\n\n # Increment the ID number\n self.spheres_marker.id += 1\n\n # Get the default parameters\n spheres_marker = self.spheres_marker\n\n if lifetime == None:\n spheres_marker.lifetime = rospy.Duration(0.0) # 0 = Marker never expires\n else:\n spheres_marker.lifetime = rospy.Duration(lifetime) # in seconds\n\n # Set the timestamp\n spheres_marker.header.stamp = rospy.Time.now()\n\n # Set marker size\n spheres_marker.scale = spheres_scale\n\n # Set marker color\n spheres_marker.color = self.getColor(color)\n\n spheres_color = self.getColor(color)\n #spheres_marker.color = spheres_color\n\n # Set the sphere positions and color\n spheres_marker.points[:] = [] # clear\n spheres_marker.colors[:] = []\n for i in range(0, len(list_of_spheres)):\n\n # Each sphere position needs to be a ROS Point Msg\n if type(list_of_spheres[i]) == Pose:\n spheres_marker.points.append( list_of_spheres[i].position ) \n spheres_marker.colors.append(spheres_color)\n elif (type(list_of_spheres[i]) == numpy.matrix) or (type(list_of_spheres[i]) == numpy.ndarray):\n pose_i = mat_to_pose(list_of_spheres[i])\n spheres_marker.points.append( pose_i.position )\n spheres_marker.colors.append(spheres_color)\n elif type(list_of_spheres[i]) == Point:\n spheres_marker.points.append(list_of_spheres[i])\n spheres_marker.colors.append(spheres_color)\n else:\n rospy.logerr(\"list_of_sphere contains unsupported type '%s' in publishSphere()\", type(list_of_spheres[i]).__name__)\n return False\n\n return self.publishMarker(spheres_marker)\n\n\n def publishText(self, pose, text, color, scale, lifetime=None):\n \"\"\"\n Publish a text Marker\n\n @param pose (numpy matrix, numpy ndarray, ROS Pose)\n @param text (string)\n @param color name (string) or RGB color value (tuple or list)\n @param scale (ROS Vector3, float)\n @param lifetime (float, None = never expire)\n \"\"\"\n\n if (self.muted == True):\n return True\n\n # Convert input pose to a ROS Pose Msg\n if (type(pose) == numpy.matrix) or (type(pose) == numpy.ndarray):\n text_pose = mat_to_pose(pose)\n elif type(pose) == Pose:\n text_pose = pose\n else:\n rospy.logerr(\"Pose is unsupported type '%s' in publishText()\", type(pose).__name__)\n return False\n\n # Convert input scale to a ROS Vector3 Msg\n if type(scale) == Vector3:\n text_scale = scale\n elif type(scale) == float:\n text_scale = Vector3(scale, scale, scale)\n else:\n rospy.logerr(\"Scale is unsupported type '%s' in publishText()\", type(scale).__name__)\n return False\n\n # Increment the ID number\n self.text_marker.id += 1\n\n # Get the default parameters\n text_marker = self.text_marker\n\n if lifetime == None:\n text_marker.lifetime = rospy.Duration(0.0) # 0 = Marker never expires\n else:\n text_marker.lifetime = rospy.Duration(lifetime) # in seconds\n\n # Set the timestamp\n text_marker.header.stamp = rospy.Time.now()\n\n # Set the pose\n text_marker.pose = text_pose\n\n # Set marker size\n text_marker.scale = text_scale\n\n # Set marker color\n text_marker.color = self.getColor(color)\n\n text_marker.text = text\n\n return self.publishMarker(text_marker)\n\n \n#------------------------------------------------------------------------------#\n\n\ndef pose_to_mat(pose):\n \"\"\"\n Convert a ROS Pose msg to a 4x4 matrix.\n\n @param pose (ROS geometry_msgs.msg.Pose)\n\n @return mat 4x4 matrix (numpy.matrix)\n \"\"\"\n\n quat = [pose.orientation.x, pose.orientation.y, pose.orientation.z, pose.orientation.w]\n pos = numpy.matrix([pose.position.x, pose.position.y, pose.position.z]).T\n mat = numpy.matrix(tf.transformations.quaternion_matrix(quat))\n mat[0:3, 3] = pos\n\n return mat\n\n\ndef mat_to_pose(mat):\n \"\"\"\n Convert a homogeneous transformation matrix to a ROS Pose msg.\n\n @param mat 4x4 homogenous transform (numpy.matrix or numpy.ndarray)\n\n @return pose (ROS geometry_msgs.msg.Pose)\n \"\"\"\n\n pose = Pose()\n pose.position.x = mat[0,3]\n pose.position.y = mat[1,3]\n pose.position.z = mat[2,3]\n\n quat = tf.transformations.quaternion_from_matrix(mat)\n pose.orientation.x = quat[0]\n pose.orientation.y = quat[1]\n pose.orientation.z = quat[2]\n pose.orientation.w = quat[3]\n\n return pose\n" ]	[ [ "numpy.matrix", "numpy.fabs" ] ]
lclc19/vertex-ai-samples	[ "1844df54a6fc3d7afff1110a6758afaf13181b19" ]	[ "community-content/tf_keras_text_classification_distributed_single_worker_gpus_with_gcloud_local_run_and_vertex_sdk/trainer/task.py" ]	[ "# Copyright 2021 Google LLC\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport argparse\nimport os\n\nimport tensorflow as tf\n\nfrom tensorflow.keras import layers, losses\nfrom tensorflow.keras.layers.experimental.preprocessing import TextVectorization\n\nimport distribution_utils\nimport utils\n\nVOCAB_SIZE = 10000\nMAX_SEQUENCE_LENGTH = 250\n\ndef parse_args():\n\n parser = argparse.ArgumentParser()\n\n # Using environment variables for Cloud Storage directories\n # see more details in https://cloud.google.com/vertex-ai/docs/training/code-requirements\n parser.add_argument(\n '--model-dir', default=os.getenv('AIP_MODEL_DIR'), type=str,\n help='a Cloud Storage URI of a directory intended for saving model artifacts')\n parser.add_argument(\n '--tensorboard-log-dir', default=os.getenv('AIP_TENSORBOARD_LOG_DIR'), type=str,\n help='a Cloud Storage URI of a directory intended for saving TensorBoard')\n parser.add_argument(\n '--checkpoint-dir', default=os.getenv('AIP_CHECKPOINT_DIR'), type=str,\n help='a Cloud Storage URI of a directory intended for saving checkpoints')\n\n parser.add_argument(\n '--num-gpus', default=0, type=int, help='number of gpus')\n parser.add_argument(\n '--epochs', default=25, type=int, help='number of training epochs')\n parser.add_argument(\n '--batch-size', default=16, type=int, help='mini-batch size')\n parser.add_argument(\n '--model-version', default=1, type=int, help='model version')\n\n parser.add_argument(\n '--local-mode', action='store_true', help='use local mode when running on your local machine')\n\n args = parser.parse_args()\n\n return args\n\ndef download_data(data_dir):\n \"\"\"Download data.\"\"\"\n\n if not os.path.exists(data_dir):\n os.makedirs(data_dir)\n\n data_url = \"https://storage.googleapis.com/download.tensorflow.org/data/stack_overflow_16k.tar.gz\"\n dataset = tf.keras.utils.get_file(\n fname=\"stack_overflow_16k.tar.gz\",\n origin=data_url,\n untar=True,\n cache_dir=data_dir,\n cache_subdir=\"\",\n )\n dataset_dir = os.path.join(os.path.dirname(dataset))\n\n return dataset_dir\n\n\ndef load_dataset(dataset_dir, batch_size, validation_split=0.2, seed=42):\n\n train_dir = os.path.join(dataset_dir, 'train')\n test_dir = os.path.join(dataset_dir, 'test')\n\n raw_train_ds = tf.keras.preprocessing.text_dataset_from_directory(\n train_dir,\n batch_size=batch_size,\n validation_split=validation_split,\n subset='training',\n seed=seed)\n\n raw_val_ds = tf.keras.preprocessing.text_dataset_from_directory(\n train_dir,\n batch_size=batch_size,\n validation_split=validation_split,\n subset='validation',\n seed=seed)\n\n raw_test_ds = tf.keras.preprocessing.text_dataset_from_directory(\n test_dir,\n batch_size=batch_size,\n )\n\n for text_batch, label_batch in raw_train_ds.take(1):\n for i in range(10):\n print(\"Question: \", text_batch.numpy()[i])\n print(\"Label:\", label_batch.numpy()[i])\n\n for i, label in enumerate(raw_train_ds.class_names):\n print(\"Label\", i, \"corresponds to\", label)\n\n return raw_train_ds, raw_val_ds, raw_test_ds\n\ndef build_model(num_classes, loss, optimizer, metrics):\n # vocab_size is VOCAB_SIZE + 1 since 0 is used additionally for padding.\n model = tf.keras.Sequential([\n layers.Embedding(VOCAB_SIZE + 1, 64, mask_zero=True),\n layers.Conv1D(64, 5, padding=\"valid\", activation=\"relu\", strides=2),\n layers.GlobalMaxPooling1D(),\n layers.Dense(num_classes)\n ])\n\n model.compile(\n loss=loss,\n optimizer=optimizer,\n metrics=metrics)\n\n return model\n\ndef train(model, train_dataset, validation_dataset, epochs, tensorboard_log_dir, checkpoint_dir):\n\n tensorboard_callback = tf.keras.callbacks.TensorBoard(\n log_dir=tensorboard_log_dir,\n update_freq=1\n )\n checkpoint_callback = tf.keras.callbacks.ModelCheckpoint(\n filepath=os.path.join(checkpoint_dir, 'cp-{epoch:04d}.ckpt'),\n verbose=1,\n save_weights_only=True,\n save_freq=\"epoch\",\n period=100\n )\n\n history = model.fit(\n train_dataset,\n epochs=epochs,\n validation_data=validation_dataset,\n callbacks=[tensorboard_callback, checkpoint_callback]\n )\n\n print('Training accuracy: {acc}, loss: {loss}'.format(\n acc=history.history['accuracy'][-1], loss=history.history['loss'][-1]))\n print('Validation accuracy: {acc}, loss: {loss}'.format(\n acc=history.history['val_accuracy'][-1], loss=history.history['val_loss'][-1]))\n\n return\n\ndef get_string_labels(predicted_scores_batch, class_names):\n predicted_labels = tf.argmax(predicted_scores_batch, axis=1)\n predicted_labels = tf.gather(class_names, predicted_labels)\n return predicted_labels\n\ndef predict(export_model, class_names, inputs):\n predicted_scores = export_model.predict(inputs)\n predicted_labels = get_string_labels(predicted_scores, class_names)\n return predicted_labels\n\ndef main():\n\n args = parse_args()\n\n local_data_dir = './tmp/data'\n\n local_model_dir = './tmp/model'\n local_checkpoint_dir = './tmp/checkpoints'\n local_tensorboard_log_dir = './tmp/logs'\n\n #TODO: update when gcsfuse ready\n gcsfuse_ready = False\n\n model_dir = args.model_dir or local_model_dir\n checkpoint_dir = (gcsfuse_ready and\n args.checkpoint_dir) or local_checkpoint_dir\n tensorboard_log_dir = args.tensorboard_log_dir or local_tensorboard_log_dir\n\n class_names = ['csharp', 'java', 'javascript', 'python']\n class_indices = dict(zip(class_names, range(len(class_names))))\n num_classes = len(class_names)\n print(f' class names: {class_names}')\n print(f' class indices: {class_indices}')\n print(f' num classes: {num_classes}')\n\n strategy = distribution_utils.get_distribution_mirrored_strategy(\n num_gpus=args.num_gpus)\n print('Number of devices: {}'.format(strategy.num_replicas_in_sync))\n\n global_batch_size = args.batch_size * strategy.num_replicas_in_sync\n print(f'Global batch size: {global_batch_size}')\n\n dataset_dir = download_data(local_data_dir)\n raw_train_ds, raw_val_ds, raw_test_ds = load_dataset(dataset_dir, global_batch_size)\n\n vectorize_layer = TextVectorization(\n max_tokens=VOCAB_SIZE,\n output_mode='int',\n output_sequence_length=MAX_SEQUENCE_LENGTH)\n\n train_text = raw_train_ds.map(lambda text, labels: text)\n vectorize_layer.adapt(train_text)\n print('The vectorize_layer is adapted')\n\n def vectorize_text(text, label):\n text = tf.expand_dims(text, -1)\n return vectorize_layer(text), label\n\n # Retrieve a batch (of 32 reviews and labels) from the dataset\n text_batch, label_batch = next(iter(raw_train_ds))\n first_question, first_label = text_batch[0], label_batch[0]\n print(\"Question\", first_question)\n print(\"Label\", first_label)\n print(\"Vectorized question:\", vectorize_text(first_question, first_label)[0])\n\n train_ds = raw_train_ds.map(vectorize_text)\n val_ds = raw_val_ds.map(vectorize_text)\n test_ds = raw_test_ds.map(vectorize_text)\n\n AUTOTUNE = tf.data.AUTOTUNE\n\n def configure_dataset(dataset):\n return dataset.cache().prefetch(buffer_size=AUTOTUNE)\n\n train_ds = configure_dataset(train_ds)\n val_ds = configure_dataset(val_ds)\n test_ds = configure_dataset(test_ds)\n\n print('Build model')\n loss = losses.SparseCategoricalCrossentropy(from_logits=True),\n optimizer = 'adam'\n metrics = ['accuracy']\n\n with strategy.scope():\n model = build_model(\n num_classes=num_classes,\n loss=loss,\n optimizer=optimizer,\n metrics=metrics,\n )\n\n train(\n model=model,\n train_dataset=train_ds,\n validation_dataset=val_ds,\n epochs=args.epochs,\n tensorboard_log_dir=tensorboard_log_dir,\n checkpoint_dir=checkpoint_dir\n )\n\n test_loss, test_accuracy = model.evaluate(test_ds)\n print(\"Int model accuracy: {:2.2%}\".format(test_accuracy))\n\n with strategy.scope():\n export_model = tf.keras.Sequential(\n [vectorize_layer, model,\n layers.Activation('softmax')])\n\n export_model.compile(\n loss=losses.SparseCategoricalCrossentropy(from_logits=False),\n optimizer='adam',\n metrics=['accuracy'])\n\n loss, accuracy = export_model.evaluate(raw_test_ds)\n print(\"Accuracy: {:2.2%}\".format(accuracy))\n\n model_path = os.path.join(model_dir, str(args.model_version))\n model.save(model_path)\n print(f'Model version {args.model_version} is saved to {model_dir}')\n\n print(f'Tensorboard logs are saved to: {tensorboard_log_dir}')\n\n print(f'Checkpoints are saved to: {checkpoint_dir}')\n utils.gcs_upload(\n dir=checkpoint_dir,\n local_dir=local_checkpoint_dir,\n gcs_dir=args.checkpoint_dir,\n gcsfuse_ready=gcsfuse_ready,\n local_mode=args.local_mode\n )\n\n return\n\nif __name__ == '__main__':\n main()" ]	[ [ "tensorflow.keras.preprocessing.text_dataset_from_directory", "tensorflow.keras.layers.Activation", "tensorflow.keras.layers.experimental.preprocessing.TextVectorization", "tensorflow.keras.losses.SparseCategoricalCrossentropy", "tensorflow.keras.layers.Embedding", "tensorflow.keras.layers.Conv1D", "tensorflow.keras.layers.GlobalMaxPooling1D", "tensorflow.keras.layers.Dense", "tensorflow.expand_dims", "tensorflow.gather", "tensorflow.keras.utils.get_file", "tensorflow.keras.callbacks.TensorBoard", "tensorflow.argmax" ] ]
hfisser/s2_trucks	[ "323e73edb82e314e6695e8cf8d89c2de22f54b04" ]	[ "detect_trucks/TruckDetector.py" ]	[ "####################################################\n# Author: Henrik Fisser, 2020\n####################################################\n\nfrom array_utils.plot import plot_img\n\nimport os, warnings\nimport pandas as pd\nimport numpy as np\nimport geopandas as gpd\nimport xarray as xr\nfrom shapely.geometry import box\nfrom scipy.stats import linregress, spearmanr\nfrom datetime import datetime\n\nfrom array_utils.math import normalized_ratio, rescale\nfrom array_utils.geocoding import lat_from_meta, lon_from_meta, metadata_to_bbox_epsg4326\nfrom osm_utils.utils import get_roads, rasterize_osm\nfrom utils.ProgressBar import ProgressBar\n\nwarnings.filterwarnings(\"ignore\")\n\ndir_ancillary = os.path.join(\"F:\" + os.sep + \"Masterarbeit\", \"DLR\", \"project\", \"1_truck_detection\", \"truth\")\nTHRESHOLDS = pd.read_csv(os.path.join(dir_ancillary, \"thresholds.csv\"), index_col=0)\nRGB_VECTORS = pd.read_csv(os.path.join(dir_ancillary, \"rgb_vector_clusters.csv\"), index_col=0)\n\n# assume reflectance rescaled to [0., 1.]\n# REFLECTANCE\nMIN_RED = THRESHOLDS[\"red_low\"][0]\nMAX_RED = THRESHOLDS[\"red_high\"][0]\n#MAX_RED_BOX = THRESHOLDS[\"box_mean_red_high\"][0]\nMIN_GREEN = THRESHOLDS[\"green_low\"][0]\nMAX_GREEN = THRESHOLDS[\"green_high\"][0]\n#MAX_GREEN_BOX = THRESHOLDS[\"box_mean_green_high\"][0]\nMIN_BLUE = THRESHOLDS[\"blue_low\"][0]\nMAX_BLUE = THRESHOLDS[\"blue_high\"][0]\n#MAX_BLUE_BOX = THRESHOLDS[\"box_mean_blue_high\"][0]\nMIN_RGB_STD = THRESHOLDS[\"min_std\"][0] / 3\n# VEGETATION\nMAX_NDVI = THRESHOLDS[\"ndvi_mean\"][0] + THRESHOLDS[\"ndvi_std\"][0] * 3\n# RATIOS\nMIN_BLUE_RED_RATIO = 0\nMIN_BLUE_GREEN_RATIO = 0\nMIN_GREEN_BLUE_RATIO = 0\nMIN_RED_BLUE_RATIO = 0\n# SPATIAL\nMEAN_MAX_DIST_GREEN = THRESHOLDS[\"mean_max_dist_green\"][0]\nMEAN_MAX_DIST_RED = THRESHOLDS[\"mean_max_dist_red\"][0]\nMAX_MAX_DIST_GREEN = THRESHOLDS[\"max_max_dist_green\"][0]\nMAX_MAX_DIST_RED = THRESHOLDS[\"max_max_dist_red\"][0]\nMAX_ANGLE_BR_BG = THRESHOLDS[\"mean_red_green_spatial_angle\"][0] + THRESHOLDS[\"std_red_green_spatial_angle\"][0] * 3\n# SPECTRAL ANGLE\n#MIN_R_SQUARED = THRESHOLDS[\"mean_rgb_rsquared\"][0] - THRESHOLDS[\"std_rgb_rsquared\"][0] * 3\nDEFAULT_MIN_CORRELATION = 0.5\nMAX_SLOPE = 10\nMIN_SLOPE = 0.05\n\n# Open Street Maps buffer\nOSM_BUFFER = 25\n\n# Sensing offset\nSECONDS_OFFSET_B02_B04 = 1.01 # seconds\nTRUCK_LENGTH = 18.75 # meters\n\nHOME = os.path.dirname(__file__)\n\n\nclass Detector:\n def __init__(self, min_r_squared=None, min_blue_green_ratio=None, min_blue_red_ratio=None):\n \"\"\"\n Detector class for detecting large moving vehicles on roads using Sentinel-2 data\n :param min_r_squared: float minimum correlation threshold\n :param min_blue_green_ratio: float minimum blue-green ratio for detection\n :param min_blue_red_ratio: float minimum blue-red ratio for detection\n \"\"\"\n self.min_r_squared = min_r_squared\n self.min_blue_green = min_blue_green_ratio\n self.min_blue_red = min_blue_red_ratio\n self.min_score = None\n self.band_stack_np = None\n self.lat, self.lon = None, None\n self.trucks_np = None\n self.crs = None\n\n def pre_process(self, band_dict, metadata, subset_box=None):\n \"\"\"\n rescales data to 0-1 and calculates lat, lon coordinates, masks to OSM roads\n :param band_dict: dict holding 3 arrays with shape (height, width), keys are B02, B03, B04, B08\n :param metadata: dict metadata from rasterio IO\n :param subset_box: dict with int ymin, ymax, xmin, xmax\n \"\"\"\n self.min_r_squared = DEFAULT_MIN_CORRELATION #if self.min_r_squared is None else self.min_r_squared\n if not isinstance(band_dict, dict):\n raise TypeError(\"'band_dict' must be a dictionary\")\n try:\n test = band_dict[\"B02\"], band_dict[\"B03\"], band_dict[\"B04\"], band_dict[\"B08\"]\n except KeyError:\n raise KeyError(\"'band_dict' must contain 'B02', 'B03', 'B04', 'B08'\")\n if not isinstance(metadata, dict):\n raise TypeError(\"'metadata' must be a dictionary\")\n self.crs = metadata[\"crs\"]\n try:\n self.lat, self.lon = metadata[\"lat\"], metadata[\"lon\"]\n except KeyError:\n try:\n self.lat, self.lon = lat_from_meta(metadata), lon_from_meta(metadata)\n except KeyError as e:\n raise e\n box_utm = [np.min(self.lat), np.max(self.lon), np.max(self.lat), np.min(self.lon)]\n box_epsg4326 = metadata_to_bbox_epsg4326(metadata)\n dir_ancil = os.path.join(HOME, \"AUXILIARY\")\n if not os.path.exists(dir_ancil):\n os.mkdir(dir_ancil)\n box_epsg4326 = list(np.flip(box_epsg4326))\n osm_mask = self.get_osm_mask(box_epsg4326, metadata[\"crs\"], band_dict[\"B02\"],\n {\"lat\": self.lat, \"lon\": self.lon},\n dir_ancil)\n band_stack_np = np.array([band_dict[\"B04\"], band_dict[\"B03\"], band_dict[\"B02\"], band_dict[\"B08\"]])\n low_rgb_mask = self.calc_low_quantile_mask(band_stack_np[0:3], [0.2]) # mask out lowest 20 % reflectances\n #high_rgb_mask = self.calc_high_quantile_mask(band_stack_np[0:3], [0.98]) # mask out highest 1 % reflectances\n band_stack_np[:, np.isnan(low_rgb_mask)] = np.nan\n #band_stack_np[:, np.isnan(high_rgb_mask)] = np.nan\n band_stack_np = osm_mask\n try:\n band_stack_np = band_stack_np[:, subset_box[\"ymin\"]:subset_box[\"ymax\"], subset_box[\"xmin\"]:subset_box[\"xmax\"]]\n self.lat = self.lat[subset_box[\"ymin\"]:subset_box[\"ymax\"] + 1]\n self.lon = self.lon[subset_box[\"xmin\"]:subset_box[\"xmax\"] + 1]\n except TypeError: # subset_box is allowed to be None\n pass\n band_stack_np_rescaled = band_stack_np.copy()\n band_stack_np = None\n band_stack_np_rescaled[np.isnan(band_stack_np_rescaled)] = 0\n band_stack_np_rescaled = rescale(band_stack_np_rescaled, 0, 1)\n # band_stack_np_rescaled[:, band_stack_np_rescaled[0] > THRESHOLDS[\"red_high\"][0]] = np.nan\n # band_stack_np_rescaled[:, band_stack_np_rescaled[1] > THRESHOLDS[\"green_high\"][0]] = np.nan\n # band_stack_np_rescaled[:, band_stack_np_rescaled[2] > THRESHOLDS[\"blue_high\"][0]] = np.nan\n band_stack_np_rescaled[band_stack_np_rescaled == 0] = np.nan\n return band_stack_np_rescaled\n\n def detect_trucks(self, band_stack_np):\n \"\"\"\n Method for detecting large moving vehicles, calls ratio-based detection and object delineation\n :param band_stack_np: numpy ndarray containing the pre-processed Sentinel-2 reflectance bands\n :return: GeoDataframe containing the detected boxes\n \"\"\"\n t0 = datetime.now()\n if not isinstance(band_stack_np, np.ndarray):\n raise TypeError(\"'band_stack_np' must be of type numpy.ndarray\")\n self.band_stack_np = band_stack_np\n self._detect()\n detections = self._context_zoom() # zoom into context around potential detection\n print(\"Duration: %s minutes\" % ((datetime.now() - t0).total_seconds() / 60))\n return detections\n\n def _detect(self):\n \"\"\"\n Detect pixels of superior blue reflectance based on band ratios\n \"\"\"\n b02, b03, b04 = self.band_stack_np[2], self.band_stack_np[1], self.band_stack_np[0]\n min_quantile_blue, max_quantile_blue = np.nanquantile(b02, [0.5]), np.nanquantile(b02, [0.999])\n max_quantile_green, max_quantile_red = np.nanquantile(b03, [0.9]), np.nanquantile(b04, [0.9])\n bg_ratio, br_ratio = normalized_ratio(b02, b03), normalized_ratio(b02, b04)\n bg = np.int8(bg_ratio > np.nanmean(b02) - np.nanmean(b03))\n br = np.int8(br_ratio > np.nanmean(b02) - np.nanmean(b04))\n blue_min = np.int8(b02 > min_quantile_blue) # exclude low 50 % blue\n blue_max = np.int8(b02 < max_quantile_blue)\n green_max = np.int8(b03 < max_quantile_green)\n red_max = np.int8(b04 < max_quantile_red)\n mask = self.expose_anomalous_pixels(self.band_stack_np)\n self.band_stack_np = self.band_stack_np mask\n self.band_stack_np[self.band_stack_np == 0] = np.nan\n # ratios B02-B03 (blue-green) and B02-B04 (blue-red)\n std_min = np.int8(np.nanstd(self.band_stack_np[0:3], 0) * 10 >= THRESHOLDS[\"q1_std_at_max_blue\"][0])\n # self.trucks_np = np.int8(bg * br * blue_min * blue_max * std_min * green_max * red_max)\n self.trucks_np = np.int8(bg * br * blue_min * green_max * red_max * std_min)\n bg_ratio, br_ratio, blue_min, blue_max, green_max, red_max, std_min = None, None, None, None, None, None, None\n\n def _context_zoom(self):\n \"\"\"\n Looks at the spatial context each detected pixel and calls method for delineating potential object\n :return: GeoDataframe containing the detected boxes\n \"\"\"\n valid = np.where(self.trucks_np == 1) # y, x indices\n boxes = [[], [], [], [], [], [], [], [], [], [], [], []]\n y_max, x_max = self.trucks_np.shape\n print(\"Context zoom\\n%s\" % (len(valid[0])))\n pb = ProgressBar(len(valid[0]), 50)\n for y, x, i in zip(valid[0], valid[1], range(len(valid[0]))):\n pb.update(i)\n if self.trucks_np[y, x] != 1: # may be the case because previously eliminated\n continue\n radius_low = int(MEAN_MAX_DIST_RED) + 2\n radius_up = radius_low + 1\n # subset around potential detection\n y_low, y_up = y - radius_low, y + radius_up\n y_low, y_up = 0 if y_low < 0 else y_low, y_max if y_up > y_max else y_up\n x_low, x_up = x - radius_low, x + radius_up\n x_low, x_up = 0 if x_low < 0 else x_low, x_max if x_up > x_max else x_up\n self.trucks_np = self.eliminate_multi_detections(self.trucks_np, y, x)\n sub_stack = self.band_stack_np[:, y_low:y_up, x_low:x_up].copy()\n if np.count_nonzero(~np.isnan(sub_stack)) == 0:\n continue\n t0 = datetime.now()\n box_test_result = self._box_test(sub_stack)\n t1 = datetime.now()\n # print(\"Total: %s\" % str((t1 - t0).total_seconds()))\n try:\n the_box = box_test_result[\"box\"]\n except KeyError:\n continue\n else:\n box_metrics = box_test_result[\"box_metrics\"]\n bounding_box = [the_box[\"xmin\"], the_box[\"ymin\"], the_box[\"xmax\"], the_box[\"ymax\"]]\n # get box in full array\n box_full_array = [x_low + bounding_box[0], y_low + bounding_box[1],\n x_low + bounding_box[2], y_low + bounding_box[3]]\n box_full_array[2] = self.lon.shape[0] - 1 if box_full_array[2] >= self.lon.shape[0] else box_full_array[2]\n box_full_array[3] = self.lat.shape[0] - 1 if box_full_array[3] >= self.lat.shape[0] else box_full_array[3]\n ymax, xmax = box_full_array[3] + 1, box_full_array[2] + 1\n ymax = self.lat.shape[0] - 1 if ymax >= self.lat.shape[0] else ymax # may happen\n xmax = self.lon.shape[0] - 1 if xmax >= self.lon.shape[0] else xmax\n bounding_box = box(self.lon[box_full_array[0]],\n self.lat[box_full_array[1]],\n self.lon[xmax],\n self.lat[ymax])\n direction_degree = box_metrics[\"direction\"]\n values = [bounding_box, box_metrics[\"spectral_angle\"], box_metrics[\"slope\"],\n self.direction_degree_to_description(direction_degree), direction_degree,\n box_test_result[\"quantile\"], box_test_result[\"speed\"], box_metrics[\"score\"],\n box_metrics[\"std\"], box_metrics[\"red_mean\"], box_metrics[\"green_mean\"], box_metrics[\"blue_mean\"]]\n for idx, value in enumerate(values):\n boxes[idx].append(value)\n detections = gpd.GeoDataFrame({\"rsquared\": boxes[1],\n \"slope\": boxes[2],\n \"direction_description\": boxes[3],\n \"direction_degree\": boxes[4],\n \"localization_quantile\": boxes[5],\n \"speed\": boxes[6],\n \"score\": boxes[7],\n \"std\": boxes[8],\n \"red_ratio\": boxes[9],\n \"green_ratio\": boxes[10],\n \"blue_ratio\": boxes[11]},\n geometry=boxes[0],\n crs=self.crs)\n print(\"\\nNumber of detections: %s\" % (len(detections)))\n return detections\n\n def _box_test(self, subset):\n \"\"\"\n looks at subset around detection and localizes object as box\n :param subset: numpy ndarray of shape (4, 9, 9) containing the reflectances of subset\n :return: dict with resulting detection box and its metrics\n \"\"\"\n t0 = datetime.now()\n subset_copy = subset.copy()\n subset[:, normalized_ratio(subset[3], subset[0]) > MAX_NDVI] = np.nan\n detection_y, detection_x = int(subset.shape[1] / 2), int(subset.shape[2] / 2) # index of detection (center)\n detection_yx = [detection_y, detection_x]\n if np.isnan(subset[0, detection_y, detection_x]): # NDVI too high. Mask here, saves time\n return {}\n detection_stack = subset[:, detection_y, detection_x].copy()\n subset[:, detection_y, detection_x] = detection_stack.copy()\n if np.count_nonzero(~np.isnan(subset[0])) < 3:\n return {}\n n_bands = subset.shape[0] - 1\n ratios = np.zeros((n_bands * 2 + 2, subset.shape[1], subset.shape[2]))\n ratio_counterparts = [[1, 2], [0, 2], [0, 1]]\n for i in range(n_bands):\n for j, k in enumerate(ratio_counterparts[i]):\n ratios[i + i + j] = normalized_ratio(subset[i], subset[k])\n ratios[6] = np.nanstd(subset[0:3], 0) * 10\n ratios[7] = np.nanstd(ratios, 0) * 10\n ratios[:, np.isnan(ratios[0])] = np.nan\n # localize potential box through high quantile\n q = np.float32([0.99])\n # print(\"Section 1 took: %s\" % str((datetime.now() - t0).total_seconds()))\n t0 = datetime.now()\n qantiles_dummy = np.float32([1, 1])\n quantiles_sum = qantiles_dummy.copy()\n while np.count_nonzero(quantiles_sum) < 6 and q[0] > 0.5:\n quantiles_sum = self.quantile_filter(ratios, q)\n if quantiles_sum is None:\n quantiles_sum = qantiles_dummy.copy()\n q -= 0.01\n q += 0.01\n # print(\"Section 2 took: %s\" % str((datetime.now() - t0).total_seconds()))\n t0 = datetime.now()\n try:\n s = all(quantiles_sum == qantiles_dummy)\n except TypeError: # then it's alright\n pass\n else:\n return {}\n try:\n quantiles_sum[quantiles_sum > 0] = 1\n except TypeError:\n return {}\n # quantiles_sum = self.eliminate_single_nonzeros(quantiles_sum)\n if np.count_nonzero(quantiles_sum > 0) < 3:\n return {}\n for j, k, t in zip([0, 2, 4], [1, 3, 5], [MAX_MAX_DIST_RED + 1, MAX_MAX_DIST_GREEN + 1, 2]):\n subset, ratios, quantiles_sum = self._eliminate_distant_pixels(subset, ratios, ratios[j] + ratios[k],\n quantiles_sum, detection_yx, t, q)\n # apply cluster exposing method twice in order to account for changes introduced by filter\n y_low, x_low, y_up, x_up = detection_y - 1, detection_x - 1, detection_y + 2, detection_x + 2\n quantiles_sum[y_low:y_up, x_low:x_up] = np.zeros((3, 3)) # temporary\n spatial_cluster = self._expose_cluster(quantiles_sum, subset[0:3], False)\n # if a cluster has high amount of values exclude corners, potentially divide large cluster\n boxes, boxes_metrics, scores, clusters = [], [], [], []\n # print(\"Section 3 took: %s\" % str((datetime.now() - t0).total_seconds()))\n t0 = datetime.now()\n for cluster in np.unique(spatial_cluster[spatial_cluster != 0]):\n spatial_cluster[detection_y, detection_x] = cluster # assign value of cluster to detection pixel\n ys, xs = np.where(spatial_cluster == cluster)\n try:\n a_box = [np.min(ys), np.min(xs), np.max(ys), np.max(xs)]\n except ValueError:\n continue\n box_arr = subset[0:3, a_box[0]:a_box[2]+1, a_box[1]:a_box[3]+1].copy()\n # if (np.nanmean(np.nanstd(box_arr, 0)) * 10) < MIN_RGB_STD * 0.5: # be tolerant here\n # continue\n cluster_sub = spatial_cluster[a_box[0]:a_box[2]+1, a_box[1]:a_box[3]+1].copy()\n cluster_sub[np.isnan(box_arr[0])] = 0\n ys, xs = np.where(spatial_cluster == cluster)\n if len(ys) < 2:\n continue\n ys, xs = self.eliminate_outlier_indices(ys, xs)\n a_box = [np.min(ys), np.min(xs), np.max(ys), np.max(xs)]\n box_arr = subset[0:3, a_box[0]:a_box[2]+1, a_box[1]:a_box[3]+1].copy()\n if np.count_nonzero(~np.isnan(box_arr)) / 3 / (box_arr.shape[1] * box_arr.shape[2]) < 0.3: # too few pixels\n continue\n box_ratios = ratios[:, a_box[0]:a_box[2]+1, a_box[1]:a_box[3]+1].copy()\n t0b = datetime.now()\n box_metrics = self._characterize_spatial_spectral(box_arr, box_ratios)\n # a_box = self._crop_box(a_box, ratios, box_metrics[\"direction\"], detection_yx)\n #print(\"Section 4b took: %s\" % str((datetime.now() - t0b).total_seconds()))\n # box_arr = subset[0:3, a_box[0]:a_box[2] + 1, a_box[1]:a_box[3] + 1].copy()\n if all([box_arr.shape[1] <= 2, box_arr.shape[2] <= 2]):\n continue\n box_metrics = self.calc_score(box_metrics, box_arr)\n if self._spatial_spectral_match(box_metrics):\n clusters.append(cluster)\n boxes.append(a_box)\n boxes_metrics.append(box_metrics)\n scores.append(box_metrics[\"score\"])\n # print(\"Section 4 took: %s\" % str((datetime.now() - t0).total_seconds()))\n t0 = datetime.now()\n scores = np.array(scores)\n try:\n max_score = np.max(scores)\n match = np.where(scores == max_score)[0][0]\n except ValueError:\n return {}\n box_metrics, selected_box = boxes_metrics[match], boxes[match]\n if np.std(selected_box) == 0:\n return {}\n if any(self.box_too_large(selected_box, MAX_MAX_DIST_RED)):\n selected_box = self._subset_by_ratios(ratios, selected_box) # subset box to high quantile ratios\n if any(self.box_too_large(selected_box, MAX_MAX_DIST_RED)):\n subset_dict = self._subset_by_boxes(subset, ratios, selected_box, [3, 4]) # try default sub boxes\n try:\n box_metrics = subset_dict[\"box_metrics\"]\n except KeyError:\n pass\n else:\n a_box = subset_dict[\"selected_box\"]\n box_arr = subset[0:3, a_box[0]:a_box[2] + 1, a_box[1]:a_box[3] + 1]\n box_metrics = self.calc_score(box_metrics, box_arr)\n if not self._spatial_spectral_match(box_metrics):\n return {}\n box_too_small = all([(selected_box[2] - selected_box[0] + 1) <= 2, (selected_box[3] - selected_box[1] + 1) <= 2])\n if box_too_small or box_metrics[\"score\"] < self.min_score:\n return {}\n the_box = {\"ymin\": selected_box[0], \"xmin\": selected_box[1],\n \"ymax\": selected_box[2], \"xmax\": selected_box[3]}\n # print(\"Section 5 took: %s\" % str((datetime.now() - t0).total_seconds()))\n return {\"box\": the_box,\n \"box_metrics\": box_metrics,\n \"quantile\": q[0],\n \"speed\": self.calc_speed(ratios[:, the_box[\"ymin\"]:the_box[\"ymax\"]+1, the_box[\"xmin\"]:the_box[\"xmax\"]+1])}\n\n def _characterize_spatial_spectral(self, sub_arr, sub_variables):\n \"\"\"\n takes a subset of reflectance stack and corresponding variables (ratios, std) and returns metrics of correlation\n and spatial relationships\n :param sub_arr: numpy ndarray of shape (3, y, x) containing the reflectance bands\n :param sub_variables: numpy ndarray of shape (7, y, x) containing ratios of reflectance bands, RGB std\n and ratios std\n :return: dict containing the box metrics\n \"\"\"\n return_dict = {}\n keys = [\"spectral_angle\", \"spatial_angle\", \"slope\", \"red_length\", \"green_length\", \"direction\",\n \"blue_mean\", \"green_mean\", \"red_mean\", \"red_ratio_max\", \"green_ratio_max\", \"blue_ratio_max\"]\n for key in keys:\n return_dict[key] = np.nan\n return_dict_copy = return_dict.copy()\n blue_ratios = np.nansum(sub_variables[4:6], 0) + sub_arr[2] * 10 # sum of blue ratios\n green_ratios = np.nansum(sub_variables[2:4], 0) + sub_arr[1] * 10 # sum of green ratios\n red_ratios = np.nansum(sub_variables[0:2], 0) + sub_arr[0] * 10 # sum of red ratios\n try:\n try:\n blue_y, blue_x = self.crop_2d_indices(np.where(blue_ratios == np.nanmax(blue_ratios)))\n except ValueError:\n return return_dict\n else:\n green_ratios[blue_y, blue_x] = np.nan # set to nan in order to avoid double target\n green_y, green_x = self.crop_2d_indices(np.where(green_ratios == np.nanmax(green_ratios)))\n red_ratios[blue_y, blue_x] = np.nan # avoid double target\n red_ratios[green_y, green_x] = np.nan # \"\"\n red_y, red_x = self.crop_2d_indices(np.where(red_ratios == np.nanmax(red_ratios)))\n except IndexError:\n return return_dict\n blue_indices = [blue_y, blue_x]\n blue_red_spatial_vector = self.calc_vector([red_y, red_x], blue_indices) # spatial vector blue to red\n blue_green_spatial_vector = self.calc_vector([green_y, green_x], blue_indices) # spatial vector blue to green\n return_dict = {\"red_length\": self.calc_vector_length(blue_red_spatial_vector),\n \"green_length\": self.calc_vector_length(blue_green_spatial_vector),\n \"spatial_angle\": self.calc_vector_angle_in_degrees(blue_red_spatial_vector,\n blue_green_spatial_vector)}\n if not self._spatial_spectral_match(return_dict): # check that in order to reduce run time\n return return_dict_copy # if spatial metrics do not satisfy thresholds return here alread\n given_vector = np.hstack([sub_variables[4:6, blue_y, blue_x], # stack of variables and target pixels\n sub_variables[2:4, green_y, green_x],\n sub_variables[0:2, red_y, red_x],\n sub_variables[6, blue_y, blue_x],\n sub_variables[6, green_y, green_x],\n sub_variables[6, red_y, red_x],\n sub_variables[7, blue_y, blue_x],\n sub_variables[7, green_y, green_x],\n sub_variables[7, red_y, red_x],\n sub_arr[2, blue_y, blue_x],\n sub_arr[2, green_y, green_x],\n sub_arr[2, red_y, red_x],\n sub_arr[1, green_y, green_x],\n sub_arr[1, blue_y, blue_x],\n sub_arr[1, red_y, red_x],\n sub_arr[0, red_y, red_x],\n sub_arr[0, blue_y, blue_x],\n sub_arr[0, green_y, green_x]])\n col_names, spectral_angles, slopes, spearman = [], [], [], []\n for i in range(7):\n col_names = col_names + [\"rgb_vector\" + str(i) + str(j) for j in [0, 1, 2]]\n # calculate spearmanr correlations between given variables and all reference variables\n for row in RGB_VECTORS.iterrows():\n r = row[1]\n ref_vector = np.array([r[col_name] for col_name in col_names])\n regression = linregress(given_vector, ref_vector)\n spearman.append(spearmanr(given_vector, ref_vector)[0])\n #spectral_angles.append(regression.rvalue)\n slopes.append(regression.slope)\n # use mean of all spearmanr correlation coefficients as indicator for agreement with reference dataset\n return_dict[\"spectral_angle\"] = np.nanmean(spearman) #np.nanquantile(spectral_angles, [0.75])[0] - np.nanstd(spectral_angles)\n return_dict[\"slope\"] = np.nanmean(slopes)\n return_dict[\"direction\"] = self.calc_vector_direction_in_degree(np.mean(np.vstack([blue_red_spatial_vector,\n blue_green_spatial_vector]),\n axis=0))\n return_dict[\"red_mean\"] = np.nanmean(sub_arr[0])\n return_dict[\"green_mean\"] = np.nanmean(sub_arr[1])\n return_dict[\"blue_mean\"] = np.nanmean(sub_arr[2])\n return_dict[\"red_ratio_max\"] = np.nanmax(np.nanmax(sub_variables[0:2]))\n return_dict[\"green_ratio_max\"] = np.nanmax(np.nanmax(sub_variables[2:4]))\n return_dict[\"blue_ratio_max\"] = np.nanmax(np.nanmax(sub_variables[4:6]))\n return return_dict\n\n def _subset_by_ratios(self, ratios, selected_box):\n original_box = selected_box.copy()\n box_ratios = ratios[:, selected_box[0]:selected_box[2]+1, selected_box[1]:selected_box[3]+1]\n q = np.float32([0.2])\n too_large_y, too_large_x = True, True\n while any([too_large_y, too_large_x]) and q[0] < 1:\n too_large_y, too_large_x = self.box_too_large(selected_box, MAX_MAX_DIST_RED)\n if any([too_large_y, too_large_x]):\n quantiles_sum = self.quantile_filter(box_ratios, q)\n if quantiles_sum is not None:\n ys, xs = np.where(quantiles_sum != 0)\n try:\n selected_box = [min(ys), min(xs), max(ys), max(xs)]\n except ValueError:\n q += 0.01\n continue\n q += 0.01\n if selected_box != original_box:\n selected_box[2] = original_box[0] + selected_box[2]\n selected_box[3] = original_box[1] + selected_box[3]\n selected_box[0] += original_box[0]\n selected_box[1] += original_box[1]\n return selected_box\n\n def _subset_by_boxes(self, subset, ratios, selected_box, window_sizes):\n box_arr = subset[0:3, selected_box[0]:selected_box[2] + 1, selected_box[1]:selected_box[3] + 1]\n box_ratios = ratios[:, selected_box[0]:selected_box[2] + 1, selected_box[1]:selected_box[3] + 1]\n boxes, boxes_metrics, boxes_rsquared, boxes_rgb_sums, boxes_spatial_angle = [], [], [], [], []\n for w in window_sizes:\n y_indices_low = np.arange(0, box_arr.shape[1] - w + 1, 1)\n x_indices_low = np.arange(0, box_arr.shape[2] - w + 1, 1)\n y_indices_up = [y + w for y in y_indices_low]\n x_indices_up = [x + w for x in x_indices_low]\n for y_low, y_up in zip(y_indices_low, y_indices_up):\n for x_low, x_up in zip(x_indices_low, x_indices_up):\n sub_box_arr = box_arr[:, y_low:y_up, x_low:x_up]\n sub_box_ratios = box_ratios[:, y_low:y_up, x_low:x_up]\n box_metrics = self._characterize_spatial_spectral(sub_box_arr, sub_box_ratios)\n if self._spatial_spectral_match(box_metrics):\n max_values = [np.nanmax(sub_box_arr[i]) for i in range(sub_box_arr.shape[0])]\n boxes.append([y_low, x_low, y_up - 1, x_up - 1]) # -1 due to indexing\n boxes_metrics.append(box_metrics)\n boxes_rsquared.append(box_metrics[\"spectral_angle\"])\n boxes_rgb_sums.append(np.sum(max_values))\n boxes_spatial_angle.append(box_metrics[\"spatial_angle\"])\n combined = np.array(boxes_rsquared) + np.array(boxes_rgb_sums) - np.array(boxes_spatial_angle)\n try:\n max_combined = np.max(combined)\n except ValueError:\n return {}\n try:\n match = np.where(combined == max_combined)[0][0]\n except IndexError:\n return {}\n new_box = boxes[match]\n selected_box[2] = selected_box[0] + new_box[2]\n selected_box[3] = selected_box[1] + new_box[3]\n selected_box[0] += new_box[0]\n selected_box[1] += new_box[1]\n return {\"box_metrics\": boxes_metrics[match], \"selected_box\": selected_box}\n\n def _eliminate_distant_pixels(self, sub_arr, ratios, band_ratios, quantiles_sum, center, threshold, quantile):\n try:\n ys, xs = np.where(band_ratios > np.nanquantile(band_ratios, quantile))\n except ValueError:\n return sub_arr\n else:\n for y, x in zip(ys, xs):\n if self.calc_vector_length(self.calc_vector(center, [y, x])) > threshold:\n sub_arr[:, y, x] = np.nan\n ratios[:, y, x] = np.nan\n quantiles_sum[y, x] = 0\n return sub_arr, ratios, quantiles_sum\n\n def _expose_cluster(self, target_arr, band_stack, exclude_corners=True):\n target_arr[np.isnan(target_arr)] = 0\n if np.count_nonzero(target_arr) == 0:\n return target_arr\n try:\n center = [int(target_arr.shape[0] / 2), int(target_arr.shape[1] / 2)]\n except IndexError:\n return target_arr\n ys, xs = np.where(target_arr != 0)\n yet_seen, cluster_value, clusters = [], 0, target_arr.copy()\n for y, x in zip(ys, xs):\n distance_center = self.calc_vector_length(self.calc_vector([y, x], center)) - 1\n rgb_slice = band_stack[0:3, y, x]\n max_idx = np.where(rgb_slice == np.nanmax(rgb_slice))[0][0]\n distance_wrong = [distance_center > t for t in [MAX_MAX_DIST_RED, MEAN_MAX_DIST_RED, MEAN_MAX_DIST_GREEN]]\n max_idx_wrong = [True, max_idx not in [0, 1], max_idx not in [0, 1, 2]]\n should_continue = False\n for condition_a, condition_b in zip(distance_wrong, max_idx_wrong):\n if condition_a and condition_b:\n clusters[y, x], should_continue = 0, True\n break\n if should_continue:\n continue\n if not [y, x] in yet_seen:\n cluster_value += 1\n clusters, yet_seen = self._search_adjacent_non_zero(clusters, [y, x], cluster_value, yet_seen,\n exclude_corners)\n return clusters\n\n def _crop_box(self, given_box, ratios, direction, detection_yx):\n max_size = MAX_MAX_DIST_RED * 2\n box_size = (given_box[2] - given_box[0] + 1) * (given_box[3] - given_box[1] + 1)\n direction_match = any(np.abs([x - direction for x in [0, 90, 180, 270]]) < 45)\n q = [0.5]\n while direction_match and box_size >= max_size and q[0] < 1:\n box_ratios = ratios[:, given_box[0]:given_box[2] + 1, given_box[1]:given_box[3] + 1]\n quantiles = self.quantile_filter(box_ratios, q)\n if quantiles is not None:\n try:\n # always retain value 1 at detection\n quantiles[np.abs(detection_yx[0] - given_box[0]), np.abs(detection_yx[1] - given_box[1])] = 1\n except IndexError:\n pass\n ys, xs = np.where(quantiles != 0)\n try:\n given_box[2] = int(given_box[0] + max(ys))\n given_box[3] = int(given_box[1] + max(xs))\n given_box[0] += min(ys)\n given_box[1] += min(xs)\n except ValueError:\n q[0] += 0.1\n continue\n else:\n box_size = (given_box[2] - given_box[0] + 1) * (given_box[3] - given_box[1] + 1)\n if box_size >= max_size:\n q[0] += 0.1\n return given_box\n\n def _search_adjacent_non_zero(self, arr, point, new_value, yet_seen, exclude_corners):\n \"\"\"\n looks for non zeros in 3x3 window around point in array and assigns a new value to these non-zeros\n :param arr: np array\n :param point: list of int y, x indices\n :param new_value: int value to assign\n :param yet_seen: list of lists, each list is a point with int y, x indices that has been seen before\n :param exclude_corners: bool, if True the corners of 3x3 window are excluded\n :return: tuple of np array and list\n \"\"\"\n arr_modified = arr.copy()\n original_value = arr_modified[point[0], point[1]].copy()\n arr_modified[point[0], point[1]] = 0\n ymin, ymax = point[0]-1, point[0]+2\n xmin, xmax = point[1]-1, point[1]+2\n ymin, xmin = 0 if ymin < 0 else ymin, 0 if xmin < 0 else xmin\n window_3x3 = arr_modified[ymin:ymax, xmin:xmax].copy()\n if exclude_corners:\n for corner_y, corner_x in zip([0, 0, 2, 2], [0, 2, 0, 2]):\n try:\n window_3x3[corner_y, corner_x] = 0\n except IndexError:\n continue\n ys, xs = np.where(window_3x3 != 0)\n for y_local, x_local in zip(ys, xs):\n y, x = ymin + y_local, xmin + x_local\n if [y, x] not in yet_seen:\n arr_modified[y, x] = new_value\n arr_modified, yet_seen = self._search_adjacent_non_zero(arr_modified, [y, x], new_value, yet_seen,\n exclude_corners)\n yet_seen.append([y, x])\n value = original_value if point in yet_seen else new_value\n if point not in yet_seen:\n yet_seen.append(point)\n arr_modified[point[0], point[1]] = value\n return arr_modified, yet_seen\n\n def calc_speed(self, ratios):\n resolution = 10 # meters\n blue_ratios = np.nansum(ratios[4:6], 0)\n red_ratios = np.nansum(ratios[0:2], 0)\n green_ratios = np.nansum(ratios[2:4], 0)\n try:\n max_blue, max_red, max_green = np.nanmax(blue_ratios), np.nanmax(red_ratios), np.nanmax(green_ratios)\n except IndexError:\n return 0\n diameter = (np.max(ratios.shape[1:3]) - (1.5 - max_blue)) * resolution\n kilometers_hour = (diameter * (3600 / SECONDS_OFFSET_B02_B04)) / 1000\n return kilometers_hour\n\n def _spatial_spectral_match(self, metrics_dict):\n is_match = True\n has_values = 3\n# try:\n # ratios_means = [metrics_dict[\"red_ratio_max\"], metrics_dict[\"green_ratio_max\"], metrics_dict[\"blue_ratio_max\"]]\n # except KeyError:\n # has_values -= 1\n # else:\n # ratios_high = np.max(ratios_means) > 0.2\n # ratios_high_all = all([mean_value > 0.05 for mean_value in ratios_means])\n # ratios_high_all = ratios_high_all or sum([mean_value > 0.25 for mean_value in ratios_means]) >= 2\n # ratios_high_two = sum([mean_value > 0.15 for mean_value in ratios_means]) > 1\n # is_match = ratios_high ratios_high_all * ratios_high_two\n # try:\n # is_match = metrics_dict[\"std\"] >= MIN_RGB_STD\n # except KeyError:\n # has_values -= 1\n try:\n is_match = metrics_dict[\"spectral_angle\"] >= self.min_r_squared\n except KeyError:\n has_values -= 1\n try:\n is_match = metrics_dict[\"score\"] >= self.min_score\n except KeyError:\n has_values -= 1\n try:\n green_length = metrics_dict[\"green_length\"]\n red_length = metrics_dict[\"red_length\"]\n is_match = green_length < red_length\n is_match = red_length < (MAX_MAX_DIST_RED + 0.5)\n is_match = green_length < (MAX_MAX_DIST_GREEN + 0.5)\n except KeyError:\n has_values -= 1\n # try:\n # is_match = metrics_dict[\"slope\"] < MAX_SLOPE\n # is_match = metrics_dict[\"slope\"] > MIN_SLOPE\n # except KeyError:\n # has_values -= 1\n # try:\n # is_match = metrics_dict[\"spatial_angle\"] < MAX_ANGLE_BR_BG\n # except KeyError:\n # has_values -= 1\n if has_values == 0:\n return False\n else:\n return is_match\n\n @staticmethod\n def calc_score(metrics_dict, sub_arr):\n metrics_dict[\"std\"] = np.nanmean(np.nanstd(sub_arr, 0)) 10\n reflectance_means_sum = (metrics_dict[\"red_mean\"] + metrics_dict[\"blue_mean\"] + metrics_dict[\n \"green_mean\"]) * 10\n ratio_means_sum = metrics_dict[\"red_ratio_max\"] + metrics_dict[\"green_ratio_max\"] \\\n + metrics_dict[\"blue_ratio_max\"]\n metrics_dict[\"score\"] = metrics_dict[\"spectral_angle\"] + metrics_dict[\"std\"] - np.abs(\n 1 - metrics_dict[\"slope\"]) \\\n + reflectance_means_sum + ratio_means_sum - metrics_dict[\"spatial_angle\"] / 100\n return metrics_dict\n\n @staticmethod\n def calc_primary_accuracy(detected_boxes, validation_boxes):\n out_keys = [\"validation_percentage\", \"detection_percentage\", \"validation_intersection_percentage\",\n \"detection_intersection_percentage\"]\n out_dict = {}\n lens = [len(detected_boxes) == 0, len(validation_boxes) == 0]\n if lens[0]:\n print(\"No entries in 'detected_boxes'\")\n if lens[1]:\n print(\"No entries in 'validation_boxes'\")\n if any(lens):\n for key in out_keys:\n out_dict[key] = np.nan\n return out_dict\n intersections = {\"validation\": [], \"detection\": []}\n intersection_areas = {\"validation\": [], \"detection\": []}\n keys = [\"validation\", \"detection\"]\n for boxes_a, boxes_b, key in zip([validation_boxes, detected_boxes], [detected_boxes, validation_boxes], keys):\n for detected_box in boxes_a.geometry:\n for i, validation_box in enumerate(boxes_b.geometry):\n if detected_box.intersects(validation_box):\n intersections[key].append(i)\n detected_gpd = gpd.GeoDataFrame({\"geometry\": [detected_box]}).set_geometry(\"geometry\")\n validation_gpd = gpd.GeoDataFrame({\"geometry\": [validation_box]}).set_geometry(\"geometry\")\n detected_gpd.crs = detected_boxes.crs\n validation_gpd.crs = detected_gpd.crs\n intersected = gpd.overlay(detected_gpd, validation_gpd, how=\"intersection\")\n intersection_areas[key].append(intersected.area[0] / detected_gpd.area[0] * 100)\n out_values = [(len(intersections[\"validation\"]) / len(validation_boxes)) * 100,\n (len(intersections[\"detection\"]) / len(detected_boxes)) * 100,\n np.nanmean(np.array(intersection_areas[\"validation\"])),\n np.nanmean(np.array(intersection_areas[\"detection\"]))]\n for key, value in zip(out_keys, out_values):\n out_dict[key] = value\n return out_dict\n\n @staticmethod\n def eliminate_single_nonzeros(arr):\n for y in range(arr.shape[0]):\n for x in range(arr.shape[1]):\n window_3x3 = arr[y-1:y+2, x-1:x+2]\n if np.count_nonzero(window_3x3[~np.isnan(window_3x3)]) < 2:\n arr[y, x] = 0\n return arr\n\n @staticmethod\n def eliminate_outlier_indices(ys, xs):\n dtype_ys, dtype_xs = ys.dtype, xs.dtype\n ys, xs = ys.astype(np.float32), xs.astype(np.float32)\n unique_ys, unique_xs = np.unique(ys), np.unique(xs)\n n = len(ys)\n n_unique_ys, n_unique_xs = len(unique_ys), len(unique_xs)\n amount_unique_ys, amount_unique_xs = np.zeros(n_unique_ys), np.zeros(n_unique_xs)\n for unique_idx, amount_unique, indices in zip([unique_ys, unique_xs],\n [amount_unique_ys, amount_unique_xs],\n [ys, xs]):\n for i, idx in enumerate(unique_idx):\n amount_unique[i] = len(np.where(indices == idx)[0]) / n * 100\n for amounts, uniques, indices in zip([amount_unique_ys, amount_unique_xs], [unique_ys, unique_xs], [ys, xs]):\n if (amounts > 50).any(): # there is a major y\n outlier_idxs = np.where(amounts < 15)\n if len(outlier_idxs[0]) > 0:\n for outlier_idx in outlier_idxs:\n real_idx = uniques[outlier_idx]\n to_nan = indices == real_idx\n ys[to_nan] = np.nan # eliminate y and x index\n xs[to_nan] = np.nan\n ys, xs = ys[~np.isnan(ys)], xs[~np.isnan(xs)]\n return ys.astype(dtype_ys), xs.astype(dtype_xs)\n\n @staticmethod\n def quantile_filter(arr, quantile_value):\n \"\"\"\n Targets values of specified quantile and eliminates isolated values\n :param arr: numpy ndarray of shape (3, height, width) -> RGB\n :param quantile_value: list with float quantile in range of 0 and 1\n :return: numpy 2d array of shape (height, width)\n \"\"\"\n quantiles = np.array([arr[i] >= np.nanquantile(arr[i], quantile_value) for i in range(arr.shape[0])],\n dtype=np.int8)\n # quantiles_initial_sum = quantiles.sum(0)\n # if np.count_nonzero(np.int8(quantiles_initial_sum > 0) * np.int8(quantiles_initial_sum < 3)) == 0:\n # return None\n shape = quantiles.shape\n s = shape[1]\n buffers = [2, 2, 1, 1, 2, 2, s, s, s, s]\n for i in range(quantiles.shape[0]):\n for y in range(shape[1]):\n for x in range(shape[2]):\n buffer = buffers[i]\n y_low, y_up = y - buffer, y + buffer + 1\n x_low, x_up = x - buffer, x + buffer + 1\n y_low = 0 if y_low < 0 else y_low\n x_low = 0 if x_low < 0 else x_low\n y_up, x_up = shape[1] if y_up > shape[1] else y_up, shape[2] if x_up > shape[2] else x_up\n y_low = y_low - 1 if y_up == (shape[1] + 1) else y_low\n x_low = x_low - 1 if x_up == (shape[2] + 1) else x_low\n y_up, x_up = y_up + 1 if y_low == 0 else y_up, x_up + 1 if x_low == 0 else x_up\n original_value = quantiles[i, y, x]\n if original_value == 0:\n continue\n quantiles_sub = quantiles[:, y_low:y_up, x_low:x_up].copy()\n quantiles_sub[i] = np.zeros_like(quantiles_sub[i]) # look only for matches in other bands\n sums = [np.nansum(quantiles_sub[j]) for j in range(quantiles_sub.shape[0])]\n quantiles[i, y, x] = 0 if np.count_nonzero(sums) < 2 else original_value\n return quantiles.sum(0)\n\n @staticmethod\n def box_too_large(the_box, max_size):\n size_y, size_x = (the_box[2] - the_box[0] + 1), (the_box[3] - the_box[1] + 1)\n too_large_y = size_y > max_size\n too_large_x = size_x > max_size\n return too_large_y, too_large_x\n\n # not really needed\n @staticmethod\n def calc_low_ratios_mask(ratios, min_values_ratios):\n ratio_mask = np.zeros_like(ratios[0:3], dtype=np.int8)\n only_false = np.zeros(3, dtype=np.bool)\n # reflectance and ratio filter\n for i in range(ratio_mask.shape[0]):\n idx = 2 * i\n ratio_mask[i] = np.int8((ratios[idx] + ratios[idx + 1]) > min_values_ratios[i])\n only_false[i] = np.count_nonzero(ratio_mask) == 0\n ratio_mask = ratio_mask.sum(0)\n ratio_mask[ratio_mask > 2] = 0\n ratio_mask[(2 >= ratio_mask) * (ratio_mask > 0)] = 1\n return ratio_mask, only_false\n\n @staticmethod\n def calc_low_quantile_mask(reflectances, q):\n low_quantile_red = np.int8(reflectances[0] > np.nanquantile(reflectances[0], q))\n low_quantile_green = np.int8(reflectances[1] > np.nanquantile(reflectances[1], q))\n low_quantile_blue = np.int8(reflectances[2] > np.nanquantile(reflectances[2], q))\n low_quantile_mask = np.float32(low_quantile_red + low_quantile_green + low_quantile_blue)\n low_quantile_mask[low_quantile_mask == 0] = np.nan\n low_quantile_mask[low_quantile_mask > 0] = 1\n return low_quantile_mask\n\n @staticmethod\n def calc_high_quantile_mask(reflectances, q):\n high_quantile_red = np.int8(reflectances[0] < np.nanquantile(reflectances[0], q))\n high_quantile_green = np.int8(reflectances[1] < np.nanquantile(reflectances[1], q))\n high_quantile_blue = np.int8(reflectances[2] < np.nanquantile(reflectances[2], q))\n high_quantile_mask = np.float32(high_quantile_red + high_quantile_green + high_quantile_blue)\n high_quantile_mask[high_quantile_mask == 0] = np.nan\n high_quantile_mask[high_quantile_mask > 0] = 1\n return high_quantile_mask\n\n @staticmethod\n def expose_anomalous_pixels(band_stack_np):\n w = 100\n y_bound, x_bound = band_stack_np.shape[1], band_stack_np.shape[2]\n roads = np.zeros((3, band_stack_np.shape[1], band_stack_np.shape[2]), dtype=np.float32)\n for y in range(int(np.round(y_bound / w))):\n for x in range(int(np.round(x_bound / w))):\n y_idx, x_idx = np.clip((y + 1) * w, 0, y_bound), np.clip((x + 1) * w, 0, x_bound)\n y_low, x_low = int(np.clip(y_idx - w, 0, 1e+30)), int(np.clip(x_idx - w, 0, 1e+30))\n y_up, x_up = np.clip(y_idx + w + 1, 0, y_bound), np.clip(x_idx + w + 1, 0, x_bound)\n y_size, x_size = (y_up - y_low), (x_up - x_low)\n n = y_size * x_size\n subset = band_stack_np[:, y_low:y_up, x_low:x_up]\n roads[0, y_low:y_up, x_low:x_up] = np.repeat(np.nanmedian(subset[0]), n).reshape(y_size, x_size)\n roads[1, y_low:y_up, x_low:x_up] = np.repeat(np.nanmedian(subset[1]), n).reshape(y_size, x_size)\n roads[2, y_low:y_up, x_low:x_up] = np.repeat(np.nanmedian(subset[2]), n).reshape(y_size, x_size)\n #max_diff = np.nanmax(band_stack_np[0:3] - np.nanmin(roads, 0), 0)\n #mask = np.int8(max_diff > np.nanquantile(max_diff, [0.6]))\n diff_red = band_stack_np[0] - (roads[0] / 2)\n diff_green = band_stack_np[1] - (roads[1] / 2)\n diff_blue = band_stack_np[2] - (roads[2] / 2)\n diff_stack = np.array([diff_red, diff_green, diff_blue])\n mask = np.zeros_like(diff_stack[0])\n for i in range(diff_stack.shape[0]):\n mask += np.int8(diff_stack[i] > np.nanquantile(diff_stack[i], [0.6]))\n mask[mask != 0] = 1\n mask = np.int8(mask)\n return mask\n\n @staticmethod\n def get_osm_mask(bbox, crs, reference_arr, lat_lon_dict, dir_out):\n osm_file = get_roads(bbox, [\"motorway\", \"trunk\", \"primary\"], OSM_BUFFER,\n dir_out, str(bbox).replace(\", \", \"_\")[1:-1] + \"_osm_roads\", str(crs),\n reference_arr)\n osm_vec = gpd.read_file(osm_file)\n ref_xr = xr.DataArray(data=reference_arr, coords=lat_lon_dict, dims=[\"lat\", \"lon\"])\n osm_raster = rasterize_osm(osm_vec, ref_xr).astype(np.float32)\n osm_raster[osm_raster != 0] = 1\n osm_raster[osm_raster == 0] = np.nan\n return osm_raster\n\n @staticmethod\n def crop_2d_indices(indices):\n \"\"\"\n :param indices: tuple of np int64 indices as returned by np.where\n :return: np int32 indices. Cropped if longer than 1\n \"\"\"\n return np.array([index_arr[0] for index_arr in indices]).astype(np.int32)\n\n @staticmethod\n def calc_vector_direction_in_degree(vector):\n # [1,1] -> 45°; [-1,1] -> 135°; [-1,-1] -> 225°; [1,-1] -> 315°\n y_offset = 90 if vector[0] > 0 else 0\n x_offset = 90 if vector[1] < 0 else 0\n offset = 180 if y_offset == 0 and x_offset == 90 else 0\n if vector[0] == 0:\n direction = 0.\n else:\n direction = np.degrees(np.arctan(np.abs(vector[1]) / np.abs(vector[0])))\n direction += offset + y_offset + x_offset\n return direction\n\n @staticmethod\n def direction_degree_to_description(direction_degree):\n step = 22.5\n bins = np.arange(0, 359, step, dtype=np.float32)\n descriptions = np.array([\"N\", \"NNE\", \"NE\", \"ENE\",\n \"E\", \"ESE\", \"SE\", \"SEE\",\n \"S\", \"SSW\", \"SW\", \"WSW\",\n \"W\", \"WNW\", \"NW\", \"NNW\"])\n i, b = 0, -1\n while b < direction_degree and i < len(bins):\n b = bins[i]\n i += 1\n return descriptions[i - 1]\n\n @staticmethod\n def calc_vector_angle_in_degrees(a, b):\n cos = np.dot(a, b) / np.linalg.norm(a) / np.linalg.norm(b)\n if np.abs(cos) >= 1:\n return 0\n else:\n return np.degrees(np.arccos(cos))\n\n @staticmethod\n def calc_vector(b, a):\n \"\"\"\n :param b: 1d np.float32 array or array-like\n :param a: 1d np.float32 array or array-like\n :return: 2d np.float32 array, a vector pointing to origin\n \"\"\"\n vector = []\n for i in range(len(b)):\n try:\n vector.append(np.float32(b[i] - a[i]))\n except IndexError:\n raise IndexError(\"origin and target must be of equal length\")\n return np.array(vector).astype(np.float32)\n\n @staticmethod\n def calc_vector_length(vector):\n \"\"\"\n :param vector: np array vector\n :return: np float32\n \"\"\"\n squared = np.float32([element ** 2 for element in vector])\n return np.sqrt(squared.sum()).astype(np.float32)\n\n @staticmethod\n def get_smallest_deviation(arr, value):\n dev = np.abs(arr - value)\n return int(np.where(dev == dev.min())[0][0])\n\n @staticmethod\n def eliminate_multi_detections(arr, y, x):\n y0 = y - 2 if (y - 2) >= 0 else y\n x0 = x - 2 if (x - 2) >= 0 else x\n y1 = y + 3 if (y + 3) <= arr.shape[0] else arr.shape[0]\n x1 = x + 3 if (x + 3) <= arr.shape[1] else arr.shape[1]\n arr[y0:y1, x0:x1] = np.zeros((y1 - y0, x1 - x0))\n arr[y, x] = 1 # detection of interest remains\n return arr\n" ]	[ [ "numpy.nanmax", "numpy.dot", "numpy.nanmedian", "numpy.round", "numpy.max", "numpy.zeros_like", "numpy.nanmean", "scipy.stats.spearmanr", "numpy.nanstd", "numpy.where", "numpy.hstack", "numpy.unique", "numpy.clip", "numpy.arange", "numpy.int8", "numpy.std", "numpy.nansum", "numpy.float32", "numpy.count_nonzero", "numpy.zeros", "numpy.min", "numpy.isnan", "numpy.arccos", "scipy.stats.linregress", "numpy.array", "numpy.flip", "numpy.sum", "numpy.abs", "numpy.linalg.norm", "numpy.nanquantile", "numpy.vstack" ] ]
adam-coogan/pyro	[ "6395b0f5f0b4744d3c822a39526027fb3fdb8b04" ]	[ "pyro/distributions/empirical.py" ]	[ "from __future__ import absolute_import, division, print_function\n\nimport math\nimport numbers\n\nimport torch\nfrom torch.distributions import constraints\n\nfrom pyro.distributions.torch import Categorical\nfrom pyro.distributions.torch_distribution import TorchDistribution\nfrom pyro.distributions.util import copy_docs_from, logsumexp\n\n\n@copy_docs_from(TorchDistribution)\nclass Empirical(TorchDistribution):\n r\"\"\"\n Empirical distribution associated with the sampled data.\n \"\"\"\n\n arg_constraints = {}\n support = constraints.real\n has_enumerate_support = True\n\n def __init__(self, validate_args=None):\n self._samples = None\n self._log_weights = None\n self._categorical = None\n self._samples_buffer = []\n self._weights_buffer = []\n super(TorchDistribution, self).__init__(batch_shape=torch.Size(), validate_args=validate_args)\n\n @staticmethod\n def _append_from_buffer(tensor, buffer):\n \"\"\"\n Append values from the buffer to the finalized tensor, along the\n leftmost dimension.\n\n :param torch.Tensor tensor: tensor containing existing values.\n :param list buffer: list of new values.\n :return: tensor with new values appended at the bottom.\n \"\"\"\n buffer_tensor = torch.stack(buffer, dim=0)\n return torch.cat([tensor, buffer_tensor], dim=0)\n\n def _finalize(self):\n \"\"\"\n Appends values collected in the samples/weights buffers to their\n corresponding tensors.\n \"\"\"\n if not self._samples_buffer:\n return\n self._samples = self._append_from_buffer(self._samples, self._samples_buffer)\n self._log_weights = self._append_from_buffer(self._log_weights, self._weights_buffer)\n self._categorical = Categorical(logits=self._log_weights)\n # Reset buffers.\n self._samples_buffer, self._weights_buffer = [], []\n\n @property\n def sample_size(self):\n \"\"\"\n Number of samples that constitute the empirical distribution.\n\n :return int: number of samples collected.\n \"\"\"\n self._finalize()\n if self._samples is None:\n return 0\n return self._samples.size(0)\n\n def add(self, value, weight=None, log_weight=None):\n \"\"\"\n Adds a new data point to the sample. The values in successive calls to\n ``add`` must have the same tensor shape and size. Optionally, an\n importance weight can be specified via ``log_weight`` or ``weight``\n (default value of `1` is used if not specified).\n\n :param torch.Tensor value: tensor to add to the sample.\n :param torch.Tensor weight: log weight (optional) corresponding\n to the sample.\n :param torch.Tensor log_weight: weight (optional) corresponding\n to the sample.\n \"\"\"\n if self._validate_args:\n if weight is not None and log_weight is not None:\n raise ValueError(\"Only one of ```weight`` or ``log_weight`` should be specified.\")\n\n weight_type = value.new_empty(1).float().type() if value.dtype in (torch.int32, torch.int64) \\\n else value.type()\n # Apply default weight of 1.0.\n if log_weight is None and weight is None:\n log_weight = torch.tensor(0.0).type(weight_type)\n elif weight is not None and log_weight is None:\n log_weight = math.log(weight)\n if isinstance(log_weight, numbers.Number):\n log_weight = torch.tensor(log_weight).type(weight_type)\n if self._validate_args and log_weight.dim() > 0:\n raise ValueError(\"``weight.dim() > 0``, but weight should be a scalar.\")\n\n # Seed the container tensors with the correct tensor types\n if self._samples is None:\n self._samples = value.new_tensor([])\n self._log_weights = log_weight.new_tensor([])\n # Append to the buffer list\n self._samples_buffer.append(value)\n self._weights_buffer.append(log_weight)\n\n def sample(self, sample_shape=torch.Size()):\n self._finalize()\n idxs = self._categorical.sample(sample_shape=sample_shape)\n return self._samples[idxs]\n\n def log_prob(self, value):\n \"\"\"\n Returns the log of the probability mass function evaluated at ``value``.\n Note that this currently only supports scoring values with empty\n ``sample_shape``, i.e. an arbitrary batched sample is not allowed.\n\n :param torch.Tensor value: scalar or tensor value to be scored.\n \"\"\"\n if self._validate_args:\n if value.shape != self.event_shape:\n raise ValueError(\"``value.shape`` must be {}\".format(self.event_shape))\n self._finalize()\n selection_mask = self._samples.eq(value).contiguous().view(self.sample_size, -1)\n # Return -Inf if value is outside the support.\n if not selection_mask.any():\n return self._log_weights.new_zeros(torch.Size()).log()\n idxs = torch.arange(self.sample_size)[selection_mask.min(dim=-1)[0]]\n log_probs = self._categorical.log_prob(idxs)\n return logsumexp(log_probs, dim=-1)\n\n def _weighted_mean(self, value, dim=0):\n weights = self._log_weights.reshape([-1] + (value.dim() - 1) * [1])\n max_weight = weights.max(dim=dim)[0]\n relative_probs = (weights - max_weight).exp()\n return (value * relative_probs).sum(dim=dim) / relative_probs.sum(dim=dim)\n\n @property\n def event_shape(self):\n self._finalize()\n if self._samples is None:\n return None\n return self._samples.shape[1:]\n\n @property\n def mean(self):\n self._finalize()\n if self._samples.dtype in (torch.int32, torch.int64):\n raise ValueError(\"Mean for discrete empirical distribution undefined. \" +\n \"Consider converting samples to ``torch.float32`` \" +\n \"or ``torch.float64``. If these are samples from a \" +\n \"`Categorical` distribution, consider converting to a \" +\n \"`OneHotCategorical` distribution.\")\n return self._weighted_mean(self._samples)\n\n @property\n def variance(self):\n self._finalize()\n if self._samples.dtype in (torch.int32, torch.int64):\n raise ValueError(\"Variance for discrete empirical distribution undefined. \" +\n \"Consider converting samples to ``torch.float32`` \" +\n \"or ``torch.float64``. If these are samples from a \" +\n \"`Categorical` distribution, consider converting to a \" +\n \"`OneHotCategorical` distribution.\")\n deviation_squared = torch.pow(self._samples - self.mean, 2)\n return self._weighted_mean(deviation_squared)\n\n def get_samples_and_weights(self):\n self._finalize()\n return self._samples, self._log_weights\n\n def enumerate_support(self, expand=True):\n # Empirical does not support batching, so expanding is a no-op.\n self._finalize()\n return self._samples\n" ]	[ [ "torch.Size", "torch.cat", "torch.tensor", "torch.arange", "torch.stack", "torch.pow" ] ]
maxrudolph1/robotarium_mpe	[ "025c182899c0092c95e1ed3c2a38117f257cbe25" ]	[ "sim_results/results/read_results.py" ]	[ "import numpy as np\nfrom matplotlib import pyplot as plt\nimport pandas as pd\nimport seaborn as sb\nimport matplotlib.patches as mpatches\nfrom scipy.stats import mannwhitneyu\nsb.set_theme(style=\"darkgrid\")\n\nbcfc_rew = []\nunif_rew = []\nmono_rew = []\nrand_rew = []\n\ntasks = ['navigation','coverage','transport']\nmeths = ['expert', 'assigned', 'loc_based', 'uniform', 'combined']\ndata_dict = {}\ndiff_dict = {}\nfor meth in meths:\n data_dict[meth] = {}\n for i,task in enumerate(tasks):\n if meth == 'combined':\n data_dict[meth][task] = np.sum(np.load('./'+meth+'/reward_' + 'combined' + '.npy')[i].squeeze(), axis=0)\n else:\n data_dict[meth][task] = np.sum(np.load('./'+meth+'/reward_' + task + '.npy').squeeze(), axis=0)\nother_meths = [ 'loc_based', 'uniform', 'combined']\nfor meth in other_meths:\n diff_dict[meth] = {}\n for i, task in enumerate(tasks):\n diff_dict[meth][task] = data_dict['assigned'][task] - data_dict[meth][task]\n\n\nruns = data_dict['assigned']['navigation'].shape[0]\ntask_list = []\nmeth_list = []\nval_list = []\ndiff_task_list = []\ndiff_meth_list = []\ndiff_val_list = []\nfor meth in meths:\n for task in tasks:\n for i in range(runs):\n task_list.append(task)\n meth_list.append(meth)\n val_list.append(data_dict[meth][task][i])\n\nfor meth in other_meths:\n for task in tasks:\n for i in range(runs):\n diff_task_list.append(task)\n diff_meth_list.append(meth)\n diff_val_list.append(diff_dict[meth][task][i])\n\n\ndiffs = np.array(diff_val_list)\n\nprint(np.sum(diffs >= 0) / len(diff_val_list))\n\ndf = pd.DataFrame({'task' : task_list, 'meth': meth_list, 'rew':val_list})\ndiff_df = pd.DataFrame({'task' : diff_task_list, 'meth': diff_meth_list, 'rew':diff_val_list})\n\n\nfor task in tasks:\n for meth in other_meths:\n U1, p = mannwhitneyu(data_dict[meth][task],data_dict['assigned'][task])\n nx, ny = data_dict[meth][task].shape[0], data_dict['assigned'][task].shape[0]\n\n\ncount = 0\nfig, axs = plt.subplots(1,3)\nfor i,task in enumerate(tasks):\n for j,meth in enumerate(['combined']):\n \n count += 1\n mask = data_dict['assigned'][task] > data_dict[meth][task]\n axs[i].plot(data_dict[meth][task][mask],data_dict['assigned'][task][mask], 'g.')\n axs[i].plot(data_dict[meth][task][np.logical_not(mask)],data_dict['assigned'][task][np.logical_not(mask)], 'r.')\n perf = str(np.sum(mask)/mask.shape[0])\n print(perf)\n yl = axs[i].get_ylim()\n xl = axs[i].get_xlim()\n lim = np.array(xl if xl[1] - xl[0] > yl[1] - yl[0] else yl)\n axs[i].set_xlim(lim[0], lim[1])\n axs[i].set_ylim(lim[0], lim[1])\n axs[i].set_title(perf)\n axs[i].plot(lim, lim, '-')\n axs[i].set_aspect('equal')\n\n\n## Plotting Violins\n'''\nplt.figure()\nfor op,task in enumerate(tasks):\n plt.subplot(1,3,op+1)\n cur_data = df.query(\"task == '\" + task + \"'\")\n violin_width = 1 if task == 'navigation' else 1\n ax = sb.violinplot(data=cur_data, \n x='meth', \n y='rew',\n linewidth=0,\n label='_nolegend_',\n width=violin_width)\n ax = sb.stripplot(data=cur_data,\n x='meth',\n y='rew',\n size=1.5)\n boxwidth= 0.075 if task == 'transport' else 0.075\n sb.boxplot(data=cur_data,\n x='meth',\n y='rew',\n width=boxwidth,\n fliersize=0) \n \n #patches = []\n print(len(meths))\n ax.set_xticklabels([''] * len(meths))\n ax.set_xlabel('')\n #patches = []\n patches = []\n # Collect colors of violin plots and make opaque\n for col in [ax.collections[l] for l in [0,2,4,6,8]]: #[0,2,4,6] for 4 different plots\n patches.append(col.get_facecolor())\n print(col.get_facecolor())\n col.set_alpha(.2)\n for col in [ax.collections[l] for l in [9,10,11,12,13]]:#,12,13]]: # [8,9,10,11] for 4 different plots\n col.set_alpha(.3)\n\n print('----------') \n\n patch0 = mpatches.Patch(color=patches[0], label='Expert')\n patch1 = mpatches.Patch(color=patches[1], label='BCFC (Full Pipeline)')\n patch2 = mpatches.Patch(color=patches[2], label='BCFC (Random Task Allocation)')\n patch3 = mpatches.Patch(color=patches[3], label='BCFC (Uniform Task Allocation)')\n patch4 = mpatches.Patch(color=patches[4], label='Monolithic') \n\n if task == 'transport':\n plt.legend(handles=[patch0, patch1, patch2, patch3, patch4])\n plt.ylabel('Cumulative Episodic Reward')\n else:\n plt.ylabel('')\n pass#ax.get_legend().remove()\n\n\n lab = [task in e.lower() for e in tasks]\n res = [i for i, val in enumerate(lab) if val]\n plt.title(tasks[res[0]])\n\n\n\n\nplt.figure()\nfor op,task in enumerate(tasks):\n plt.subplot(1,3,op+1)\n cur_data = diff_df.query(\"task == '\" + task + \"'\")\n violin_width = 1 if task == 'navigation' else 1\n ax = sb.violinplot(data=cur_data, \n x='meth', \n y='rew',\n linewidth=0,\n label='_nolegend_',\n width=violin_width)\n ax = sb.stripplot(data=cur_data,\n x='meth',\n y='rew',\n size=1.5)\n boxwidth= 0.075 if task == 'transport' else 0.075\n sb.boxplot(data=cur_data,\n x='meth',\n y='rew',\n width=boxwidth,\n fliersize=0) \n \n #patches = []\n print(len(meths))\n ax.set_xticklabels([''] * len(other_meths))\n ax.set_xlabel('')\n #patches = []\n patches = []\n # Collect colors of violin plots and make opaque\n for col in [ax.collections[l] for l in [0,2,4]]: #[0,2,4,6] for 4 different plots\n patches.append(col.get_facecolor())\n print(col.get_facecolor())\n col.set_alpha(.2)\n for col in [ax.collections[l] for l in [6,7,8]]:#,12,13]]: # [8,9,10,11] for 4 different plots\n col.set_alpha(.3)\n\n print('----------') \n\n\n patch0 = mpatches.Patch(color=patches[0], label='BCFC (Random Task Allocation)')\n patch1 = mpatches.Patch(color=patches[1], label='BCFC (Uniform Task Allocation)')\n patch2 = mpatches.Patch(color=patches[2], label='Monolithic') \n\n if task == 'transport':\n plt.legend(handles=[patch0, patch1, patch2])\n plt.ylabel('Cumulative Episodic Reward')\n else:\n plt.ylabel('')\n pass#ax.get_legend().remove()\n\n\n lab = [task in e.lower() for e in tasks]\n res = [i for i, val in enumerate(lab) if val]\n plt.title(tasks[res[0]])\n'''\nplt.show(block=False)\nplt.pause(0.001) # Pause for interval seconds.\ninput(\"hit[enter] to end.\")\nplt.close('all') \n\n" ]	[ [ "numpy.logical_not", "numpy.sum", "matplotlib.pyplot.subplots", "pandas.DataFrame", "scipy.stats.mannwhitneyu", "matplotlib.pyplot.close", "numpy.load", "numpy.array", "matplotlib.pyplot.show", "matplotlib.pyplot.pause" ] ]
lukassnoek/MVCA	[ "dd194140a5babb4605b9248d34508b9d9e4f799c" ]	[ "analyses/utils.py" ]	[ "import numpy as np\nfrom scipy.special import hyp2f1, gammaln\n\n\ndef get_r2(iv, dv, stack_intercept=True):\n \"\"\" Regress dv onto iv and return r-squared.\n \n Parameters\n ----------\n iv : numpy array\n Array of shape N (samples) x K (features)\n dv : numpy array\n Array of shape N (samples) x 1\n stack_intercept : bool\n Whether to stack an intercept (vector with ones of length N).\n \n Returns\n -------\n r2 : float\n R-squared model fit.\n \"\"\"\n \n if iv.ndim == 1:\n # Add axis if shape is (N,)\n iv = iv[:, np.newaxis]\n \n if stack_intercept:\n iv = np.hstack((np.ones((iv.shape[0], 1)), iv))\n \n beta = np.linalg.lstsq(iv, dv)[0]\n dv_hat = iv.dot(beta).squeeze()\n r2 = 1 - (((dv - dv_hat) 2).sum() / ((dv - dv.mean()) 2).sum())\n \n return r2\n\n\ndef vectorized_corr(arr, arr_2D):\n \"\"\" Computes the correlation between an array and each column\n in a 2D array (each column represents a variable) in a vectorized\n way. \n \n Parameters\n ----------\n arr : numpy array\n Array of shape (N,)\n arr_2D : numpy array\n Array of shape (N, P), with P indicating different variables that\n will be correlated with arr\n \n Returns\n -------\n corrs : numpy array\n Array of shape (P,) with all correlations between arr and columns in arr_2D\n \"\"\"\n \n if arr.ndim == 1:\n arr = arr[:, np.newaxis]\n \n arr_c, arr_2D_c = arr - arr.mean(), arr_2D - arr_2D.mean(axis=0)\n r_num = np.sum(arr_c * arr_2D_c, axis=0) \n r_den = np.sqrt(np.sum(arr_c ** 2, axis=0) * np.sum(arr_2D_c 2, axis=0))\n corrs = r_num / r_den\n return corrs\n\n\ndef vectorized_partial_corr(arr, c, arr_2D, stack_intercept=True):\n \"\"\" Computes the correlation between an array and each column\n in a 2D array (each column represents a variable) in a vectorized\n way. \n \n Parameters\n ----------\n arr : numpy array\n Array of shape (N,)\n c : numpy array\n Array of shape (N,) that should be partialled out of arr_2D and arr\n arr_2D : numpy array\n Array of shape (N, P), with P indicating different variables that\n will be correlated with arr\n \n Returns\n -------\n corrs : numpy array\n Array of shape (P,) with all correlations between arr and columns in arr_2D\n \"\"\"\n\n if arr.ndim == 1:\n arr = arr[:, np.newaxis]\n \n if c.ndim == 1:\n # Add axis if shape is (N,)\n c = c[:, np.newaxis]\n \n if stack_intercept:\n c = np.hstack((np.ones((c.shape[0], 1)), c))\n\n arr_resid = arr - c.dot(np.linalg.lstsq(c, arr, rcond=None)[0])\n arr_2d_resid = arr_2D - c.dot(np.linalg.lstsq(c, arr_2D, rcond=None)[0])\n \n return vectorized_corr(arr_resid, arr_2d_resid)\n\n\ndef vectorized_semipartial_corr(arr, c, arr_2D, which='2D', stack_intercept=True):\n \"\"\" Computes the semipartial correlation between an array and each column\n in a 2D array (each column represents a variable) in a vectorized\n way. \n \n Parameters\n ----------\n arr : numpy array\n Array of shape (N,)\n c : numpy array\n Array of shape (N,) that should be partialled out of arr_2D and arr\n arr_2D : numpy array\n Array of shape (N, P), with P indicating different variables that\n will be correlated with arr\n \n Returns\n -------\n corrs : numpy array\n Array of shape (P,) with all correlations between arr and columns in arr_2D\n \"\"\"\n\n if arr.ndim == 1:\n arr = arr[:, np.newaxis]\n \n if c.ndim == 1:\n # Add axis if shape is (N,)\n c = c[:, np.newaxis]\n \n if stack_intercept:\n c = np.hstack((np.ones((c.shape[0], 1)), c))\n\n if which == '2D':\n arr_2D_resid = arr_2D - c.dot(np.linalg.lstsq(c, arr_2D, rcond=None)[0])\n return vectorized_corr(arr, arr_2D_resid)\n else:\n arr_resid = arr - c.dot(np.linalg.lstsq(c, arr)[0])\n return vectorized_corr(arr_resid, arr_2D)\n\n\ndef rpdf(rho, n, rs):\n \"\"\" rho = population correlation coefficient. \"\"\"\n lnum = np.log(n-2) + gammaln(n-1) + np.log((1-rho2)*(.5(n-1))) + np.log((1-rs2)(.5(n-4)))\n lden = np.log(np.sqrt(2np.pi)) + gammaln(n-.5) + np.log((1-rhors)(n-3/2))\n fac = lnum - lden\n hyp = hyp2f1(.5, .5, (2n-1)/2, (rhors+1)/2)\n return np.exp(fac) hyp\n" ]	[ [ "numpy.log", "numpy.sqrt", "numpy.ones", "numpy.linalg.lstsq", "scipy.special.hyp2f1", "scipy.special.gammaln", "numpy.exp", "numpy.sum" ] ]
rongqingpin/iOS_app_data	[ "c9beecfb3878f64568b1d9626412ba6b346934cd" ]	[ "app_data2.py" ]	[ "import pandas as pd\nimport csv\nimport json\nimport re\n\n# load the category IDs\nflc = '/Users/pinqingkan/Desktop/Codes/Project_iTunes/'\n#flc = '/Users/Melanie/Library/Mobile Documents/com~apple~CloudDocs/Desktop/Codes/Project_iTunes/'\nfname = flc + 'IDs/iosapp_categories.csv'\nX0 = pd.read_csv(fname)\n# remove repetitive ones: 'games', 'magazines & newspapers', 'stickers'\nX0 = X0.drop(labels = [7, 28, 67], axis = 0)\n\nNcatg, N = X0.shape\n\n# creat a list of desired data\napp_keys = ['trackId',\n 'artistId',\n 'artistViewUrl', 'sellerUrl',\n 'contentAdvisoryRating', 'trackContentRating', 'averageUserRating', 'averageUserRatingForCurrentVersion',\n 'userRatingCount', 'userRatingCountForCurrentVersion',\n 'currency', 'formattedPrice', 'price',\n 'currentVersionReleaseDate', 'releaseDate', 'version',\n 'genreIds', 'primaryGenreId',\n 'fileSizeBytes',\n 'screenshotUrls', 'ipadScreenshotUrls',\n 'supportedDevices']\nNdict = len(app_keys)\napp_keys2 = ['trackId', 'description', 'features']\nNfeat = len(app_keys2)\n\nurl0 = 'https://itunes.apple.com/lookup?id='\n\n# loop through the categories\nfor icat in range(31, 33):#range(33, Ncatg)\n icategory = X0.Category.iloc[icat]\n icatid = X0.ID.iloc[icat]\n # record the data one file per category\n if (icatid >= 7000) & (icatid < 8000): fname0 = 'games'\n elif (icatid >= 13000) & (icatid < 14000): fname0 = 'magazines-newspapers'\n elif icatid >= 16000: fname0 = 'stickers'\n else: fname0 = icategory\n\n print(icategory)\n\n # load the new links\n try:\n fname = flc + 'isoapp_links/iosapp_' + icategory + '_links_072017.txt'\n with open(fname, 'r') as file:\n links = file.readlines()\n\n napp = len(links)\n for iapp in range(napp):\n match = re.search('id([\\d]+)\\?mt', links[iapp])\n if match:\n iurl = url0 + match.group(1)\n # load data from website\n Y = pd.read_json(iurl)\n\n # initialize the data\n app_dict = dict.fromkeys(app_keys)\n app_feat = dict.fromkeys(app_keys2)\n\n if len(Y) > 0:\n Y = Y['results'][0]\n\n # format & record the data\n for ikey in app_keys:\n if ikey in Y.keys():\n if ikey in ['screenshotUrls', 'ipadScreenshotUrls',\n 'supportedDevices',\n 'artistViewUrl', 'sellerUrl',\n 'genreIds']:\n app_dict[ikey] = len(Y[ikey])\n elif ikey in ['version']:\n if len(Y[ikey].encode()) == len(Y[ikey]):\n app_dict[ikey] = Y[ikey]\n else:\n app_dict[ikey] = Y[ikey]\n else:\n app_dict[ikey] = 0\n\n # record the description info\n for ikey in app_keys2:\n if ikey in Y.keys():\n app_feat[ikey] = Y[ikey]\n else:\n app_feat[ikey] = 0\n\n # convert into dataframe\n y = pd.DataFrame(app_dict, index = [0])\n\n # record the app data\n fname = flc + 'iosapp_data/app_data_' + fname0 + '.csv'\n with open(fname, 'a') as file:\n csvwriter = csv.writer(file, delimiter = '\\t')\n csvwriter.writerow(y.iloc[0,:].values)\n\n # record the description\n fname = flc + 'iosapp_data/app_descp_' + fname0 + '.json'\n with open(fname, 'a') as file:\n json.dump(app_feat, file)\n file.write('\\n')\n\n except FileNotFoundError: continue" ]	[ [ "pandas.read_csv", "pandas.read_json", "pandas.DataFrame" ] ]
cjwang/pyEX	[ "1b5f40f80110afaa4809ea48fac067033c7bdf89" ]	[ "pyEX/stocks/batch.py" ]	[ "# -- coding: utf-8 --\nimport itertools\nimport pandas as pd\nfrom multiprocessing.pool import ThreadPool\nfrom ..common import _TIMEFRAME_CHART, _getJson, _raiseIfNotStr, PyEXception, _strOrDate, _toDatetime, _BATCH_TYPES\nfrom .fundamentals import _dividendsToDF, _earningsToDF, _financialsToDF, _splitsToDF\nfrom .news import _newsToDF\nfrom .prices import chart, _bookToDF, _chartToDF\nfrom .profiles import _companyToDF, _peersToDF\nfrom .research import _statsToDF\n\n\n_MAPPING = {\n 'book': _bookToDF,\n 'chart': _chartToDF,\n 'company': _companyToDF,\n 'dividends': _dividendsToDF,\n 'earnings': _earningsToDF,\n 'financials': _financialsToDF,\n 'stats': _statsToDF,\n 'news': _newsToDF,\n 'peers': _peersToDF,\n 'splits': _splitsToDF\n}\n\n\ndef batch(symbols, fields=None, range_='1m', last=10, token='', version='', filter=''):\n '''Batch several data requests into one invocation\n\n https://iexcloud.io/docs/api/#batch-requests\n\n\n Args:\n symbols (list); List of tickers to request\n fields (list); List of fields to request\n range_ (string); Date range for chart\n last (int);\n token (string); Access token\n version (string); API version\n filter (string); filters: https://iexcloud.io/docs/api/#filter-results\n\n Returns:\n dict: results in json\n '''\n fields = fields or _BATCH_TYPES[:10] # limit 10\n\n if not isinstance(symbols, [].__class__):\n if not isinstance(symbols, str):\n raise PyEXception('batch expects string or list of strings for symbols argument')\n\n if isinstance(fields, str):\n fields = [fields]\n\n if range_ not in _TIMEFRAME_CHART:\n raise PyEXception('Range must be in %s' % str(_TIMEFRAME_CHART))\n\n if isinstance(symbols, str):\n route = 'stock/{}/batch?types={}&range={}&last={}'.format(symbols, ','.join(fields), range_, last)\n return _getJson(route, token, version, filter)\n\n if len(symbols) > 100:\n raise PyEXception('IEX will only handle up to 100 symbols at a time!')\n route = 'stock/market/batch?symbols={}&types={}&range={}&last={}'.format(','.join(symbols), ','.join(fields), range_, last)\n return _getJson(route, token, version, filter)\n\n\ndef batchDF(symbols, fields=None, range_='1m', last=10, token='', version='', filter=''):\n '''Batch several data requests into one invocation\n\n https://iexcloud.io/docs/api/#batch-requests\n\n\n Args:\n symbols (list); List of tickers to request\n fields (list); List of fields to request\n range_ (string); Date range for chart\n last (int);\n token (string); Access token\n version (string); API version\n filter (string); filters: https://iexcloud.io/docs/api/#filter-results\n\n Returns:\n DataFrame: results in json\n '''\n x = batch(symbols, fields, range_, last, token, version, filter)\n\n ret = {}\n\n if isinstance(symbols, str):\n for field in x.keys():\n ret[field] = _MAPPING.get(field, pd.io.json.json_normalize)(x[field])\n else:\n for symbol in x.keys():\n for field in x[symbol].keys():\n if field not in ret:\n ret[field] = pd.DataFrame()\n\n dat = x[symbol][field]\n dat = _MAPPING.get(field, pd.io.json.json_normalize)(dat)\n dat['symbol'] = symbol\n\n ret[field] = pd.concat([ret[field], dat], sort=True)\n return ret\n\n\ndef bulkBatch(symbols, fields=None, range_='1m', last=10, token='', version='', filter=''):\n '''Optimized batch to fetch as much as possible at once\n\n https://iexcloud.io/docs/api/#batch-requests\n\n\n Args:\n symbols (list); List of tickers to request\n fields (list); List of fields to request\n range_ (string); Date range for chart\n last (int);\n token (string); Access token\n version (string); API version\n filter (string); filters: https://iexcloud.io/docs/api/#filter-results\n\n Returns:\n dict: results in json\n '''\n fields = fields or _BATCH_TYPES\n args = []\n empty_data = []\n list_orig = empty_data.__class__\n\n if not isinstance(symbols, list_orig):\n raise PyEXception('Symbols must be of type list')\n\n for i in range(0, len(symbols), 99):\n args.append((symbols[i:i + 99], fields, range_, last, token, version, filter))\n\n pool = ThreadPool(20)\n rets = pool.starmap(batch, args)\n pool.close()\n\n ret = {}\n\n for i, d in enumerate(rets):\n symbols_subset = args[i][0]\n if len(d) != len(symbols_subset):\n empty_data.extend(list_orig(set(symbols_subset) - set(d.keys())))\n ret.update(d)\n\n for k in empty_data:\n if k not in ret:\n if isinstance(fields, str):\n ret[k] = {}\n else:\n ret[k] = {x: {} for x in fields}\n return ret\n\n\ndef bulkBatchDF(symbols, fields=None, range_='1m', last=10, token='', version='', filter=''):\n '''Optimized batch to fetch as much as possible at once\n\n https://iexcloud.io/docs/api/#batch-requests\n\n\n Args:\n symbols (list); List of tickers to request\n fields (list); List of fields to request\n range_ (string); Date range for chart\n last (int);\n token (string); Access token\n version (string); API version\n filter (string); filters: https://iexcloud.io/docs/api/#filter-results\n\n Returns:\n DataFrame: results in json\n '''\n dat = bulkBatch(symbols, fields, range_, last, token, version, filter)\n ret = {}\n for symbol in dat:\n for field in dat[symbol]:\n if field not in ret:\n ret[field] = pd.DataFrame()\n\n d = dat[symbol][field]\n d = _MAPPING[field](d)\n d['symbol'] = symbol\n ret[field] = pd.concat([ret[field], d], sort=True)\n\n return ret\n\n\ndef bulkMinuteBars(symbol, dates, token='', version='', filter=''):\n '''fetch many dates worth of minute-bars for a given symbol'''\n _raiseIfNotStr(symbol)\n dates = [_strOrDate(date) for date in dates]\n list_orig = dates.__class__\n\n args = []\n for date in dates:\n args.append((symbol, '1d', date, token, version, filter))\n\n pool = ThreadPool(20)\n rets = pool.starmap(chart, args)\n pool.close()\n\n return list_orig(itertools.chain(*rets))\n\n\ndef bulkMinuteBarsDF(symbol, dates, token='', version='', filter=''):\n '''fetch many dates worth of minute-bars for a given symbol'''\n data = bulkMinuteBars(symbol, dates, token, version, filter)\n df = pd.DataFrame(data)\n if df.empty:\n return df\n _toDatetime(df)\n df.set_index(['date', 'minute'], inplace=True)\n return df\n" ]	[ [ "pandas.concat", "pandas.DataFrame" ] ]
kfirsalo/New-Graph-ZSL	[ "76ccd15e65e915858dca9d9097ddf9252e4250d3", "76ccd15e65e915858dca9d9097ddf9252e4250d3" ]	[ "graph_ZSL_w_argmin.py", "images_graph_creator.py" ]	[ "import json\nimport multiprocessing\nfrom datetime import datetime\n\nfrom node2vec import Node2Vec\nimport pandas as pd\nimport numpy as np\nimport networkx as nx\nimport pickle\nimport os\nimport argparse\nfrom numpy import linalg as la\nfrom sklearn.metrics.pairwise import cosine_similarity\nfrom sklearn import model_selection as sk_ms\nfrom sklearn.metrics import confusion_matrix\nfrom sklearn.multiclass import OneVsRestClassifier\nfrom sklearn.linear_model import LogisticRegression\nimport random\nimport math\nimport matplotlib as mpl\nimport matplotlib.pyplot as plt\nfrom itertools import chain\nfrom utils import set_gpu\nfrom utlis_graph_zsl import hist_plot, plot_confusion_matrix, plots_2measures_vs_parameter, grid\nfrom IMDb_data_preparation_E2V import MoviesGraph\n\nrandom.seed(0)\nnp.random.seed(0)\n\nHEADER = ['movie_weights',\n 'labels_weights',\n 'embedding_type',\n 'embedding_dimension',\n 'norma_type',\n 'class_edges_threshold',\n 'seen_percentage',\n 'data_name',\n 'awa2_attributes_weight',\n 'acc',\n 'seen_acc',\n 'unseen_acc']\n\n\nclass GraphImporter:\n \"\"\"\n class that responsible to import or create the relevant graph\n \"\"\"\n def __init__(self, args):\n self.data_name = args.data_name\n self.graph_percentage = args.graph_percentage\n self.threshold = args.threshold\n self.args = args\n\n def import_imdb_multi_graph(self, weights):\n \"\"\"\n Make our_imdb multi graph using class\n :param weights:\n :return:\n \"\"\"\n weights_dict = {'movies_edges': weights[0], 'labels_edges': weights[1]}\n dict_paths = {'cast': 'data_set/IMDb title_principals.csv', 'genre': 'data_set/IMDb movies.csv'}\n imdb = MoviesGraph(dict_paths, self.args.graph_percentage)\n gnx = imdb.create_graph()\n labels = imdb.labels2int(gnx)\n knowledge_gnx, knowledge_data = imdb.create_knowledge_graph(labels, self.threshold)\n multi_gnx = imdb.weighted_multi_graph(gnx, knowledge_gnx, labels, weights_dict)\n return multi_gnx\n\n def import_imdb_weighted_graph(self, weights):\n weights_dict = {'movies_edges': weights[0], 'labels_edges': weights[1]}\n dict_paths = {'cast': 'data_set/IMDb title_principals.csv', 'genre': 'data_set/IMDb movies.csv'}\n imdb = MoviesGraph(dict_paths, self.args.graph_percentage)\n gnx = imdb.create_graph()\n labels = imdb.labels2int(gnx)\n knowledge_gnx, knowledge_data = imdb.create_knowledge_graph(labels, float(self.threshold))\n weighted_graph = imdb.weighted_graph(gnx, knowledge_gnx, labels, weights_dict)\n return weighted_graph\n\n def import_graph(self):\n graph = nx.MultiGraph()\n data_path = self.data_name + '.txt'\n path = os.path.join(self.data_name, data_path)\n with open(path, 'r') as f:\n for line in f:\n items = line.strip().split()\n att1 = str(items[0][0])\n att2 = str(items[1][0])\n graph.add_node(items[0], key=att1)\n graph.add_node(items[1], key=att2)\n sort_att = np.array([att1, att2])\n sort_att = sorted(sort_att)\n graph.add_edge(items[0], items[1], key=str(sort_att[0]) + str(sort_att[1]))\n return graph\n\n def import_awa2_graph(self, awa2_weights, specific_split, att_weight):\n from images_graph_creator import Awa2GraphCreator, ImagesEmbeddings\n weights_dict = {'classes_edges': awa2_weights[0], 'labels_edges': awa2_weights[1]}\n set_gpu(self.args.gpu)\n graph_preparation = ImagesEmbeddings(self.args)\n dict_name_class, dict_class_name = graph_preparation.dict_name_class, graph_preparation.dict_class_name\n seen_classes, unseen_classes = graph_preparation.seen_classes, graph_preparation.unseen_classes\n embeds_matrix, dict_image_embed, dict_image_class = graph_preparation.images_embed_calculator()\n dict_idx_image_class = {i: dict_name_class[dict_image_class[image]]\n for i, image in enumerate(list(dict_image_class.keys()))}\n awa2_graph_creator = Awa2GraphCreator(embeds_matrix, dict_image_embed, dict_name_class, dict_idx_image_class,\n self.args.graph_percentage, self.args)\n image_graph = awa2_graph_creator.create_image_graph()\n kg, dict_class_nodes_translation = awa2_graph_creator.imagenet_knowledge_graph()\n kg = awa2_graph_creator.attributed_graph(kg, att_weight)\n seen_classes = [dict_class_nodes_translation[c] for c in seen_classes]\n unseen_classes = [dict_class_nodes_translation[c] for c in unseen_classes]\n split = {'seen': seen_classes, 'unseen': unseen_classes}\n labels_graph = awa2_graph_creator.create_labels_graph(dict_class_nodes_translation)\n awa2_graph = awa2_graph_creator.weighted_graph(image_graph, kg, labels_graph, weights_dict)\n nx.write_gpickle(awa2_graph, 'awa2/train/awa2_graph')\n if specific_split:\n return awa2_graph, split\n else:\n split = None\n return awa2_graph, split\n\n\nclass EmbeddingCreator(object):\n def __init__(self, graph=None, dimension=None, args=None):\n self.data_name = args.data_name\n self.dim = dimension\n self.graph = graph\n\n def create_node2vec_embeddings(self):\n # path1 = os.path.join(self.data_name, 'Node2Vec_embedding.pickle')\n # path2 = os.path.join(self.data_name, 'Node2Vec_embedding.csv')\n # if os.path.exists(path1):\n # with open(path1, 'rb') as handle:\n # dict_embeddings = pickle.load(handle)\n # elif os.path.exists(path2):\n # embedding_df = pd.read_csv(path2)\n # dict_embeddings = embedding_df.to_dict(orient='list')\n # with open(path2, 'wb') as handle:\n # pickle.dump(dict_embeddings, handle, protocol=3)\n # else:\n # node2vec = Node2Vec(self.graph, dimensions=16, walk_length=30, num_walks=200, workers=1)\n # model = node2vec.fit()\n # nodes = list(self.graph.nodes())\n # dict_embeddings = {}\n # for i in range(len(nodes)):\n # dict_embeddings.update({nodes[i]: np.asarray(model.wv.get_vector(nodes[i]))})\n # with open(path1, 'wb') as handle:\n # pickle.dump(dict_embeddings, handle, protocol=3)\n node2vec = Node2Vec(self.graph, dimensions=self.dim, walk_length=80, num_walks=16, workers=2)\n model = node2vec.fit()\n nodes = list(self.graph.nodes())\n dict_embeddings = {}\n for i in range(len(nodes)):\n dict_embeddings.update({nodes[i]: np.asarray(model.wv.get_vector(str(nodes[i])))})\n return dict_embeddings\n\n def create_event2vec_embeddings(self):\n data_path = self.data_name + '_e2v_embeddings.txt'\n path = os.path.join(self.data_name, data_path)\n cond = 0\n dict_embeddings = {}\n with open(path, 'r') as f:\n for line in f:\n if cond == 1:\n items = line.strip().split()\n dict_embeddings[items[0]] = items[1:]\n cond = 1\n return dict_embeddings\n\n def create_ogre_embeddings(self, user_initial_nodes_choice=None):\n from StaticGraphEmbeddings.our_embeddings_methods.static_embeddings import StaticEmbeddings\n if user_initial_nodes_choice is not None:\n static_embeddings = StaticEmbeddings(self.data_name, self.graph, initial_size=100, initial_method=\"node2vec\", method=\"OGRE\", H=user_initial_nodes_choice,\n dim=self.dim, choose=\"degrees\", regu_val=0, weighted_reg=False, epsilon=0.1, file_tags=None)\n else:\n static_embeddings = StaticEmbeddings(self.data_name, self.graph, dim=self.dim)\n dict_embeddings = static_embeddings.dict_embedding\n return dict_embeddings\n\n\nclass EdgesPreparation:\n def __init__(self, graph, args, split=None):\n self.args = args\n # self.multi_graph = multi_graph\n self.split = split\n self.graph = graph\n self.label_edges = self.make_label_edges()\n self.unseen_edges, self.test_edges, self.dict_test_edges, self.dict_train_edges, self.dict_unseen_edges \\\n = self.train_test_unseen_split()\n\n def make_label_edges(self):\n \"\"\"\n Make a list with all the edge from type \"labels_edges\", i.e. edges between a movie and its class.\n :return: list with labels_edges\n \"\"\"\n data_path = self.args.data_name + '_true_edges.pickle'\n nodes = list(self.graph.nodes)\n label_edges = []\n for node in nodes:\n if str(node)[0] == 'c':\n info = self.graph._adj[node]\n neighs = list(info.keys())\n for neigh in neighs:\n if info[neigh]['key'] == 'labels_edges':\n label_edges.append([node, neigh])\n try:\n with open(os.path.join(self.args.data_name, data_path), 'wb') as handle:\n pickle.dump(label_edges, handle, protocol=3)\n except:\n pass\n return label_edges\n\n @staticmethod\n def label_edges_classes_ordered(edge_data):\n \"\"\"\n Make a dict of classes and their labels_edges they belong to. For every label_edge\n there is only one class it belongs to.\n :return: a dict of classes and their labels_edges\n \"\"\"\n dict_class_label_edge = {}\n for edge in edge_data:\n if edge[0][0] == 'c':\n label = edge[0]\n else:\n label = edge[1]\n if dict_class_label_edge.get(label) is not None:\n edges = dict_class_label_edge[label]\n edges.append(edge)\n dict_class_label_edge[label] = edges\n else:\n dict_class_label_edge.update({label: [edge]})\n return dict_class_label_edge\n\n def train_test_unseen_split(self): # unseen edges\n ratio = self.args.ratio[0]\n dict_true_edges = self.label_edges_classes_ordered(self.label_edges)\n classes = list(dict_true_edges.keys())\n for i, k in enumerate(sorted(dict_true_edges, key=lambda x: len(dict_true_edges[x]), reverse=True)):\n classes[i] = k\n seen_classes = classes[:int(self.args.seen_percentage * len(classes))]\n unseen_classes = classes[int(self.args.seen_percentage * len(classes)):]\n if self.split is not None:\n seen_classes = self.split['seen']\n unseen_classes = self.split['unseen']\n # unseen_classes.append(classes[0])\n unseen_edges, seen_edges, train_edges, test_edges = [], [], [], []\n for c in unseen_classes:\n # class_edges = list(self.graph.edges(c))\n # for edge in class_edges:\n # self.graph[edge[0]][edge[1]]['weight'] = 10\n for edge in dict_true_edges[c]:\n unseen_edges.append(edge)\n for c in seen_classes:\n seen_edges_c = []\n for edge in dict_true_edges[c]:\n seen_edges.append(edge)\n seen_edges_c.append(edge)\n random.Random(4).shuffle(seen_edges_c)\n train_edges_c = seen_edges_c[:int(ratio len(seen_edges_c))]\n test_edges_c = seen_edges_c[int(ratio * len(seen_edges_c)):]\n for edge in train_edges_c:\n train_edges.append(edge)\n if len(test_edges_c) > 0:\n for edge in test_edges_c:\n test_edges.append(edge)\n # unseen_edges = [dict_true_edges[c] for c in unseen_classes]\n # seen_edges = [dict_true_edges[c] for c in seen_classes]\n # random.Random(4).shuffle(seen_edges)\n # train_edges = seen_edges[:int(ratio * len(seen_edges))]\n # test_edges = seen_edges[int(ratio * len(seen_edges)):]\n dict_train_edges = self.label_edges_classes_ordered(train_edges)\n dict_test_edges = self.label_edges_classes_ordered(test_edges)\n dict_unseen_edges = self.label_edges_classes_ordered(unseen_edges)\n # for c in unseen_classes:\n # unseen_edges.append(dict_true_edges[c])\n return unseen_edges, test_edges, dict_train_edges, dict_test_edges, dict_unseen_edges\n\n def seen_graph(self):\n graph = self.graph\n for edge in self.unseen_edges:\n graph.remove_edge(edge[0], edge[1])\n for edge in self.test_edges:\n graph.remove_edge(edge[0], edge[1])\n return graph\n\n def ogre_initial_nodes(self, gnx):\n train_classes = list(self.dict_train_edges.keys())\n train_nodes = train_classes.copy()\n for c in train_classes:\n train_nodes.append(self.dict_train_edges[c][0][1])\n # try:\n # train_nodes.append(self.dict_train_edges[c][1][1])\n # except:\n # continue\n intial_graph = gnx.subgraph(train_nodes)\n return intial_graph\n\n\nclass Classifier:\n def __init__(self, dict_train_true, dict_test_true, dict_unseen_edges,\n dict_projections, embedding, args):\n self.args = args\n self.embedding = embedding\n self.dict_true_edges = dict_train_true\n self.dict_test_true = dict_test_true\n self.dict_unseen_edges = dict_unseen_edges\n self.norm = set(args.norm)\n self.dict_projections = dict_projections\n\n def edges_distance(self, edges):\n \"\"\"\n Calculate the distance of an edge. Take the vertices of the edge and calculate the distance between their\n embeddings.\n We use to calculate The distance with L1, l2, Cosine Similarity.\n :param edge: the edge we want to find its distance.\n :return: The distance\n \"\"\"\n embed_edges_0 = [self.dict_projections[edge[0]] for edge in edges]\n embed_edges_1 = [self.dict_projections[edge[1]] for edge in edges]\n if self.norm == set('L1 Norm'):\n norms = la.norm(np.subtract(embed_edges_0, embed_edges_1), 1, axis=1)\n elif self.norm == set('L2 Norm'):\n norms = la.norm(np.subtract(embed_edges_0, embed_edges_1), 2, axis=1)\n elif self.norm == set('cosine'):\n try:\n all_norms = cosine_similarity(embed_edges_0, embed_edges_1)\n norms = []\n for i in range(len(all_norms)):\n if np.abs(all_norms[i, i]) <= 1:\n norms.append(math.acos(all_norms[i, i]))\n elif all_norms[i, i] > 1:\n norms.append(math.acos(1))\n elif all_norms[i, i] < -1:\n norms.append(math.acos(-1))\n # norms = [math.acos(all_norms[i, i]) if np.abs(all_norms[i, i]) < 1 else math.acos(1) for i in range(len(all_norms))]\n except:\n print('a')\n else:\n raise ValueError(f\"Wrong name of norm, {self.norm}\")\n final_norms = np.array(norms).reshape(-1, 1)\n return final_norms\n\n def edge_distance(self, edge):\n \"\"\"\n Calculate the distance of an edge. Take the vertices of the edge and calculate the distance between their\n embeddings.\n We use to calculate The distance with L1, l2, Cosine Similarity.\n :param edge: the edge we want to find its distance.\n :return: The distance\n \"\"\"\n try:\n embd1 = np.array(self.dict_projections[edge[0]]).astype(float)\n embd2 = np.array(self.dict_projections[edge[1]]).astype(float)\n except:\n embd1 = np.ones(self.args.embedding_dimension).astype(float)\n embd2 = np.zeros(self.args.embedding_dimension).astype(float)\n pass\n if self.norm == set('L1 Norm'):\n norm = la.norm(np.subtract(embd1, embd2), 1)\n elif self.norm == set('L2 Norm'):\n norm = la.norm(np.subtract(embd1, embd2), 1)\n elif self.norm == set('cosine'):\n norm = math.acos(cosine_similarity(embd1.reshape(1, -1), embd2.reshape(1, -1))[0])\n else:\n raise ValueError(f\"Wrong name of norm, {self.norm}\")\n return norm\n\n def calculate_classifier_value(self, true_edges, false_edges):\n \"\"\"\n Create x and y for Logistic Regression Classifier.\n self.dict_projections: A dictionary of all nodes embeddings, where keys==nodes and values==embeddings\n :param true_edges: A list of true edges.\n :param false_edges: A list of false edges.\n :return: x_true/x_false - The feature matrix for logistic regression classifier, of true/false edge.\n The i'th row is the norm score calculated for each edge.\n y_true_edge/y_false_edge - The edges labels, [1,0] for true/ [0,1] for false.\n Also the edge of the label is concatenate to the label.\n \"\"\"\n x_true = self.edges_distance(true_edges)\n x_false = self.edges_distance(false_edges)\n # x_true, x_false = np.array(norms_true).reshape(-1, 1), np.array(norms_false).reshape(-1, 1)\n y_true_edge = np.column_stack((np.ones(shape=(len(true_edges), 1)),\n np.zeros(shape=(len(true_edges), 1)))).astype(int)\n y_false_edge = np.column_stack((np.zeros(shape=(len(false_edges), 1)),\n np.ones(shape=(len(false_edges), 1)))).astype(int)\n return x_true, x_false, y_true_edge, y_false_edge\n\n def calculate_by_single_norm(self, true_edges, false_edges):\n x_true, x_false = np.zeros(shape=(len(true_edges), 1)), np.zeros(shape=(len(false_edges), 1))\n y_true_edge, y_false_edge = np.zeros(shape=(len(true_edges), 4)).astype(int), \\\n np.zeros(shape=(len(false_edges), 4)).astype(int)\n for i, edge in enumerate(true_edges):\n norm = self.edge_distance(edge)\n x_true[i, 0] = norm\n # y_true_edge[i, 2] = edge[0]\n # y_true_edge[i, 3] = edge[1]\n y_true_edge[i, 0] = str(1)\n for i, edge in enumerate(false_edges):\n norm = self.edge_distance(edge)\n x_false[i, 0] = norm\n # y_false_edge[i, 2] = edge[0]\n # y_false_edge[i, 3] = edge[1]\n y_false_edge[i, 1] = str(1)\n return x_true, x_false, y_true_edge, y_false_edge\n\n @staticmethod\n def concat_data(x_true, x_false, y_true_edge, y_false_edge):\n \"\"\"\n split the data into rain and test for the true edges and the false one.\n :param ratio: determine the train size.\n :return: THe split data\n \"\"\"\n x_train, y_train = np.concatenate((x_true, x_false), axis=0), \\\n np.concatenate((y_true_edge, y_false_edge), axis=0)\n # y_train = np.array([y_train_edge.T[0].reshape(-1, 1), y_train_edge.T[1].reshape(-1, 1)]).T.reshape(-1,\n # 2).astype(\n # int)\n return x_train, y_train\n\n def train(self):\n \"\"\"\n Prepare the data for train, also train the classifier and make the test data divide by classes.\n :return: The classifier and dict_class_movie_test\n \"\"\"\n path2 = os.path.join(self.args.data_name, f'train/dict_{self.embedding}_{self.args.norm}.pkl')\n classes = list(self.dict_true_edges.keys())\n # for i, k in enumerate(sorted(self.dict_true_edges, key=lambda x: len(self.dict_true_edges[x]), reverse=True)):\n # classes[i] = k\n dict_class_movie_test = {}\n test_classes = list(self.dict_test_true.keys())\n unseen_classes = list(self.dict_unseen_edges.keys())\n for c in test_classes:\n dict_movie_edge = {}\n for edge in self.dict_test_true[c]:\n if edge[0][0] == 'c':\n movie = edge[1]\n else:\n movie = edge[0]\n dict_movie_edge[movie] = edge\n dict_class_movie_test[c] = dict_movie_edge.copy()\n for c in unseen_classes:\n dict_movie_edge = {}\n for edge in self.dict_unseen_edges[c]:\n if edge[0][0] == 'c':\n movie = edge[1]\n else:\n movie = edge[0]\n dict_movie_edge[movie] = edge\n dict_class_movie_test[c] = dict_movie_edge.copy()\n # if not os.path.exists(os.path.join('Graph-ZSL', self.args.data_name)):\n # os.makedirs(os.path.join('Graph-ZSL', self.args.data_name))\n with open(path2, 'wb') as fid:\n pickle.dump(dict_class_movie_test, fid)\n return dict_class_movie_test\n\n def evaluate(self, dict_class_movie_test):\n # evaluate\n classes = list(dict_class_movie_test.keys())\n pred_true = []\n pred = []\n # for i, k in enumerate(sorted(dict_class_movie_test, key=lambda x: len(dict_class_movie_test[x]), reverse=True)):\n # classes[i] = k\n num_classes = len(classes)\n dict_measures = {'acc': {}, 'precision': {}}\n dict_class_measures = {}\n for c in classes:\n class_movies = list(dict_class_movie_test[c].keys())\n count = 0\n for m in class_movies:\n edges = np.array([np.repeat(m, num_classes), classes]).T\n class_test = np.zeros(shape=(len(edges), 1))\n # if set(self.args.embedding) != set('OGRE'):\n class_test = self.edges_distance(edges)\n # else:\n # for i, edge in enumerate(edges):\n # norm = self.edge_distance(edge)\n # class_test[i, 0] = norm\n # _, probs = self.predict_edge_classification(classif2, class_test)\n # pred_index = np.argmax(probs.T[0])\n pred_index = np.argmax(class_test)\n prediction = edges[pred_index]\n real_edge = list(dict_class_movie_test[c][m])\n pred_true.append(c)\n if prediction[0][0] == 'c':\n pred.append(prediction[0])\n else:\n pred.append(prediction[1])\n if prediction[0] == real_edge[0]:\n if prediction[1] == real_edge[1]:\n count += 1\n elif prediction[1] == real_edge[0]:\n if prediction[0] == real_edge[1]:\n count += 1\n accuracy = count / len(class_movies)\n dict_measures['acc'] = accuracy\n dict_class_measures[c] = dict_measures.copy()\n with open(os.path.join(self.args.data_name, f'dict_class_measures_{self.embedding}_{self.args.norm}.pkl'),\n 'wb') as handle:\n pickle.dump(dict_class_measures, handle, protocol=3)\n # TODO dict class measures for every ratio\n return dict_class_measures, pred, pred_true\n\n def evaluate_for_hist(self, dict_class_movie_test):\n # evaluate\n classes = list(dict_class_movie_test.keys())\n hist_real_unseen_pred = np.zeros(len(classes))\n hist_real_unseen_first_unseen = np.zeros(len(classes))\n pred_true = []\n pred = []\n # for i, k in enumerate(sorted(dict_class_movie_test, key=lambda x: len(dict_class_movie_test[x]), reverse=True)):\n # classes[i] = k\n num_classes = len(classes)\n seen_flag = np.zeros(int(self.args.seen_percentagelen(classes)))\n unseen_flag = np.ones(len(classes)-int(self.args.seen_percentagelen(classes)))\n classes_flag = np.concatenate((seen_flag, unseen_flag))\n dict_measures = {'acc': {}, 'precision': {}}\n dict_class_measures = {}\n for i, c in enumerate(classes):\n class_movies = list(dict_class_movie_test[c].keys())\n count = 0\n for m in class_movies:\n edges = np.array([np.repeat(m, num_classes), classes]).T\n class_test = np.zeros(shape=(len(edges), 1))\n # if set(self.args.embedding) != set('OGRE'):\n class_test = self.edges_distance(edges)\n # else:\n # for j, edge in enumerate(edges):\n # norm = self.edge_distance(edge)\n # class_test[j, 0] = norm\n # _, probs = self.predict_edge_classification(classif2, class_test)\n # pred_index = np.argmax(probs.T[0])\n try:\n class_norm_test = np.column_stack((np.column_stack((class_test, classes)), classes_flag))\n except:\n print('a')\n sorted_class_norm = class_norm_test[np.argsort(class_norm_test[:, 0])]\n # if set(self.args.norm) == set('cosine'):\n # sorted_class_norm = np.flip(sorted_class_norm)\n # sort_classes = sorted_class_norm.T[0]\n # else:\n sort_classes = sorted_class_norm.T[1]\n sort_norm = sorted_class_norm.T[0].astype(float)\n sort_classes_flag = sorted_class_norm.T[2].astype(float)\n # class_test[::-1].sort(axis=0)\n prediction = np.array([m, sort_classes[0]])\n # prediction = edges[pred_index]\n real_edge = list(dict_class_movie_test[c][m])\n pred_true.append(c)\n if i > int(self.args.seen_percentagelen(classes)):\n place = np.where(sort_classes == c)[0][0]\n hist_real_unseen_pred[place] += 1\n place = np.where(sort_classes_flag == 1)[0][0]\n if self.args.unseen_weight_advantagesort_norm[place] < sort_norm[0]:\n pred.append(sort_classes[place])\n else:\n pred.append(sort_classes[0])\n # pred.append(sort_classes[0])\n # if prediction[0][0] == 'c':\n # pred.append(prediction[0])\n # else:\n # pred.append(prediction[1])\n if prediction[0] == real_edge[0]:\n if prediction[1] == real_edge[1]:\n count += 1\n elif prediction[1] == real_edge[0]:\n if prediction[0] == real_edge[1]:\n count += 1\n accuracy = count / len(class_movies)\n dict_measures['acc'] = accuracy\n dict_class_measures[c] = dict_measures.copy()\n with open(os.path.join(self.args.data_name, f'dict_class_measures_{self.embedding}_{self.args.norm}.pkl'),\n 'wb') as handle:\n pickle.dump(dict_class_measures, handle, protocol=3)\n # TODO dict class measures for every ratio\n return dict_class_measures, pred, pred_true, hist_real_unseen_pred\n\n def hist_plot_for_unseen_dist_eval(self, distances):\n title = 'Histogram Of The Distance Between \\n Unseen Label Norm And Predicted Norm'\n x_label = f'Distance, limit:{len(distances)}'\n y_label = 'Count'\n hist_plot(distances, title, x_label, y_label)\n plt.savefig(f'{self.args.data_name}/plots/hist_distance_real_unseen-prediction_'\n f'{self.embedding}_{self.args.norm}_{int(100self.args.seen_percentage)}_seen_percent')\n\n def confusion_matrix_maker(self, dict_class_measures, pred, pred_true):\n conf_matrix = confusion_matrix(pred_true, pred, labels=list(dict_class_measures.keys()))\n seen_true_count = 0\n seen_count = 0\n unseen_true_count = 0\n unseen_count = 0\n seen_number = int(self.args.seen_percentage len(conf_matrix))\n classes = list(dict_class_measures.keys())\n seen_idx = []\n unseen_idx = []\n for i, c in enumerate(classes):\n if len(set([c]).intersection(set(self.dict_unseen_edges.keys()))) > 0:\n unseen_idx.append(i)\n else:\n seen_idx.append(i)\n for i in seen_idx:\n seen_true_count += conf_matrix[i][i]\n for j in range(len(classes)):\n seen_count += conf_matrix[i][j]\n for i in unseen_idx:\n unseen_true_count += conf_matrix[i][i]\n for j in range(len(conf_matrix)):\n unseen_count += conf_matrix[i][j]\n # for i in range(len(conf_matrix))[:seen_number]:\n # seen_true_count += conf_matrix[i][i]\n # for j in range(len(conf_matrix)):\n # seen_count += conf_matrix[i][j]\n # for i in range(len(conf_matrix))[seen_number:]:\n # unseen_true_count += conf_matrix[i][i]\n # for j in range(len(conf_matrix)):\n # unseen_count += conf_matrix[i][j]\n accuracy = (seen_true_count + unseen_true_count) / (seen_count + unseen_count)\n seen_accuracy = seen_true_count / seen_count\n unseen_accuracy = unseen_true_count / unseen_count\n print(f'accuracy all: {accuracy}')\n print(f'accuracy all seen: {seen_accuracy}')\n print(f'accuracy all unseen: {unseen_accuracy}')\n return accuracy, seen_accuracy, unseen_accuracy, conf_matrix\n\n def plot_confusion_matrix_all_classes(self, conf_matrix):\n plt.figure(0)\n title = f'Confusion Matrix, ZSL {self.args.data_name} \\n' \\\n f'{self.embedding} {self.args.norm} {int(100 * self.args.seen_percentage)} Percent Seen'\n x_title = f\"True Labels {int(100 * self.args.seen_percentage)}/{100 - int(100 * self.args.seen_percentage)}\" \\\n f\" (seen/unseen)\"\n y_title = f\"Predicted Labels\"\n plot_confusion_matrix(conf_matrix, title, x_title, y_title)\n plt.savefig(f'{self.args.data_name}/plots/confusion_matrix_{self.embedding}_{self.args.norm}'\n f'_{int(100 * self.args.seen_percentage)}_seen_percent')\nfrom dataclasses import dataclass\n@dataclass\nclass InventoryItem:\n \"\"\"Class for keeping track of an item in inventory.\"\"\"\n data_name: str\n threshold: float\n norm: str\n embedding: str\n false_per_true: str\n norm: str\n\n\ndef define_args(params):\n print(params)\n weights = np.array([params['weights_movie_movie'], params['weights_movie_class']]).astype(float)\n parser = argparse.ArgumentParser()\n parser.add_argument('--data_name', default=params['data_name']) # our_imdb, awa2\n parser.add_argument('--threshold', default=params['threshold'])\n parser.add_argument('--norm', default=params['norma_types']) # cosine / L2 Norm / L1 Norm\n parser.add_argument('--embedding', default=params['embedding_type']) # Node2Vec / Event2Vec / OGRE\n # embedding = params[2]\n parser.add_argument('--false_per_true', default=10)\n parser.add_argument('--ratio', default=[0.8])\n parser.add_argument('--seen_percentage', default=float(params['seen_percentage']))\n parser.add_argument('--embedding_dimension', default=int(params['embedding_dimensions']))\n parser.add_argument('--unseen_weight_advantage', default=0.9)\n parser.add_argument('--graph_percentage', default=1)\n if params['data_name'] == 'awa2':\n parser.add_argument('--awa2_attributes_weight', default=params['awa2_attributes_weight'])\n import torch\n cuda = torch.cuda.is_available()\n parser.add_argument('--cnn', default='materials/resnet50-base.pth')\n if cuda:\n parser.add_argument('--gpu', default='0')\n else:\n parser.add_argument('--gpu', default='-1')\n parser.add_argument('--consider-trains', action='store_false')\n\n parser.add_argument('--output', default=None)\n parser.add_argument('--images_threshold', default=0.10)\n # embedding_dimension = params[3].astype(int)\n args = parser.parse_args()\n return args, weights\n\n\ndef obj_func_grid(params, specific_split=True, split=None): # split False or True\n \"\"\"\n Main Function for link prediction task.\n :return:\n \"\"\"\n args, weights = define_args(params)\n np.random.seed(0)\n # ratio_arr = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]\n graph_maker = GraphImporter(args)\n # multi_graph = graph_maker.import_imdb_multi_graph(weights)\n if args.data_name == 'our_imdb':\n weighted_graph = graph_maker.import_imdb_weighted_graph(weights)\n elif args.data_name == 'awa2':\n awa2_att_weight = params['awa2_attributes_weight']\n weighted_graph, split = graph_maker.import_awa2_graph(weights, specific_split, awa2_att_weight)\n else:\n raise ValueError(f\"Wrong name of DataSet, {args.data_name}\")\n edges_preparation = EdgesPreparation(weighted_graph, args, split)\n # dict_true_edges = edges_preparation.label_edges_classes_ordered(edges_preparation.label_edges)\n # dict_false_edges = edges_preparation.make_false_label_edges(dict_true_edges)\n dict_train_true = edges_preparation.dict_train_edges\n dict_test_true = edges_preparation.dict_test_edges\n dict_unseen_edges = edges_preparation.dict_unseen_edges\n graph = edges_preparation.seen_graph()\n embeddings_maker = EmbeddingCreator(graph, args.embedding_dimension, args)\n if args.embedding == 'Node2Vec':\n dict_embeddings = embeddings_maker.create_node2vec_embeddings()\n elif args.embedding == 'Event2Vec':\n dict_embeddings = embeddings_maker.create_event2vec_embeddings()\n elif args.embedding == 'OGRE':\n initial_nodes = edges_preparation.ogre_initial_nodes(graph)\n dict_embeddings = embeddings_maker.create_ogre_embeddings(user_initial_nodes_choice=initial_nodes)\n else:\n raise ValueError(f\"Wrong name of embedding, {args.embedding}\")\n classifier = Classifier(dict_train_true, dict_test_true, dict_unseen_edges,\n dict_embeddings, args.embedding, args)\n dict_class_movie_test = classifier.train()\n dict_class_measures_node2vec, pred, pred_true, hist_real_unseen_pred = classifier.evaluate_for_hist(dict_class_movie_test)\n # classifier.hist_plot_for_unseen_dist_eval(hist_real_unseen_pred)\n accuracy, seen_accuracy, unseen_accuracy, conf_matrix = classifier.confusion_matrix_maker(\n dict_class_measures_node2vec, pred, pred_true)\n # classifier.plot_confusion_matrix_all_classes(conf_matrix)\n return accuracy, seen_accuracy, unseen_accuracy\n\n\ndef flatten_dict(d):\n def items():\n for key, value in d.items():\n if isinstance(value, dict):\n for subkey, subvalue in flatten_dict(value).items():\n yield key + \".\" + subkey, subvalue\n else:\n yield key, value\n return dict(items())\n\n\ndef config_to_str(config):\n config = flatten_dict(config)\n return [str(config.get(k, \"--\")) for k in HEADER]\n\n\ndef run_grid(grid_params, res_dir, now):\n grid_params = grid_params if type(grid_params) is dict else json.load(open(grid_params, \"rt\"))\n res_filename = os.path.join(res_dir, f\"{grid_params['data_name'][0]}_grid_{now}.csv\")\n out = open(res_filename, \"wt\")\n out.write(f\"{','.join(HEADER)}\\n\")\n for config in grid(grid_params):\n param = {p: config[i] for i, p in enumerate(list(grid_params.keys()))}\n acc, seen_acc, unseen_acc = obj_func_grid(param)\n table_row = config_to_str(param)\n table_row[HEADER.index('acc')] = str(acc)\n table_row[HEADER.index('seen_acc')] = str(seen_acc)\n table_row[HEADER.index('unseen_acc')] = str(unseen_acc)\n out.write(f\"{','.join(table_row)}\\n\")\n out.close()\n\n\ndef main():\n seen_accuracies, unseen_accuracies = [], []\n parameters = {\n \"data_name\": ['our_imdb'], # 'awa2', 'our_imdb'\n \"embedding_type\": [\"Node2Vec\"],\n \"embedding_dimensions\": [32, 64, 128, 256],\n # \"weights_movie_class\": [1],\n # \"weights_movie_movie\": [1],\n \"weights_movie_class\": np.logspace(-2, 3, 6),\n \"weights_movie_movie\": np.logspace(-2, 3, 6),\n \"norma_types\": ['cosine'],\n \"threshold\": [0.3, 0.6, 0.9],\n \"seen_percentage\": [0.8],\n # \"seen_percentage\": np.linspace(0.1, 0.9, 9)\n \"awa2_attributes_weight\": [100] # 100 is the best for now\n }\n num = 0\n for param in grid(parameters):\n dict_param = {p: param[i] for i, p in enumerate(list(parameters.keys()))}\n # param = np.array([w_m_m, w_m_c, e_type, dim, norma_type, threshold, per, data, w_att])\n print(f'iteration number {num}')\n num += 1\n acc, seen_acc, unseen_acc = obj_func_grid(dict_param)\n seen_accuracies.append(seen_acc100)\n unseen_accuracies.append(unseen_acc100)\n # print(\"all accuracy: \", acc)\n dict_measures = {\"unseen_accuracy\": unseen_accuracies, \"seen_accuracy\": seen_accuracies}\n plots_2measures_vs_parameter(dict_measures, parameters[\"seen_percentage\"], 'seen Percentage', 'our_imdb',\n 'Zero Shot Learning', \"Accuracy\", parameters[\"norma_types\"][0],\n parameters[\"embedding_type\"][0])\n\n\nif __name__ == '__main__':\n res_dir = \"C:\\\\Users\\\\kfirs\\\\lab\\\\Zero Shot Learning\\\\New-Graph-ZSL\\\\grid_results\"\n # now = datetime.now().strftime(\"%d%m%y_%H%M%S\")\n now = \"01_03_21\"\n parameters = {\n \"data_name\": ['our_imdb'], # 'awa2', 'our_imdb'\n \"embedding_type\": [\"Node2Vec\"],\n \"embedding_dimensions\": [32, 64, 128, 256],\n # \"weights_movie_class\": [1],\n # \"weights_movie_movie\": [1],\n \"weights_movie_class\": np.logspace(-2, 3, 6),\n \"weights_movie_movie\": np.logspace(-2, 3, 6),\n \"norma_types\": ['cosine'],\n \"threshold\": [0.3, 0.6, 0.9],\n \"seen_percentage\": [0.8],\n # \"seen_percentage\": np.linspace(0.1, 0.9, 9)\n \"awa2_attributes_weight\": [100] # 100 is the best for now\n }\n processes = []\n parameters_by_procesess = []\n for w_m_m in parameters[\"weights_movie_movie\"]:\n for w_m_c in parameters[\"weights_movie_class\"]:\n param_by_parameters = parameters.copy()\n param_by_parameters[\"weights_movie_movie\"] = [w_m_m]\n param_by_parameters[\"weights_movie_class\"] = [w_m_c]\n parameters_by_procesess.append(param_by_parameters)\n for i in range(len(parameters_by_procesess)):\n proc = multiprocessing.Process(target=run_grid, args=(parameters_by_procesess[i], res_dir, now, ))\n processes.append(proc)\n proc.start()\n for p in processes:\n p.join()\n\n", "import argparse\nimport json\nimport os.path as osp\nfrom sklearn.metrics import confusion_matrix\nfrom sklearn.neighbors import KDTree\nfrom sklearn.preprocessing import normalize\nimport matplotlib.pyplot as plt\nimport matplotlib as mpl\nimport numpy as np\nfrom itertools import chain\nimport networkx as nx\nimport random\n\nimport torch\nfrom torch.utils.data import DataLoader\n\nfrom models.resnet import make_resnet50_base\n\nimport sys\n\nsys.path.insert(1, \"./ZSL _DataSets\")\nfrom image_folder import ImageFolder\nfrom utils import set_gpu, pick_vectors\nfrom utlis_graph_zsl import get_classes, classes_split\n\n\nclass ImagesEmbeddings:\n def __init__(self, args, data_path, split_path, save_path):\n self.data_path = data_path\n self.split_path = split_path\n self.images_embed_path = osp.join(save_path, 'matrix_embeds.npy')\n self.dict_image_embed_path = osp.join(save_path, 'dict_image_embed.npy')\n self.dict_image_class_path = osp.join(save_path, 'dict_image_class.npy')\n self.classes_path = osp.join(save_path, 'classes_ordered.npy')\n self.args = args\n self.seen_classes, self.unseen_classes = self.classes()\n self.dict_name_class, self.dict_class_name = self.classes_names_translation()\n self.cnn = self.cnn_maker()\n\n def classes(self):\n seen_classes, unseen_classes = classes_split(self.args.dataset, self.data_path, self.split_path)\n return seen_classes, unseen_classes\n\n def classes_names_translation(self):\n awa2_split = json.load(open(self.split_path, 'r'))\n train_names = awa2_split['train_names']\n test_names = awa2_split['test_names']\n seen_classes, unseen_classes = self.classes()\n dict_name_class = {name: c for name, c in\n zip(chain(train_names, test_names), chain(seen_classes, unseen_classes))}\n dict_class_name = {c: name for name, c in\n zip(chain(train_names, test_names), chain(seen_classes, unseen_classes))}\n return dict_name_class, dict_class_name\n\n def cnn_maker(self):\n cnn = make_resnet50_base()\n cnn.load_state_dict(torch.load(self.args.cnn))\n if self.args.gpu == 0:\n cnn = cnn.cuda()\n cnn.eval()\n return cnn\n\n def one_class_images_embed(self, dataset, embed_matrix, count):\n loader = DataLoader(dataset=dataset, batch_size=32,\n shuffle=False, num_workers=2)\n c = 0\n for batch_id, batch in enumerate(loader, 1):\n data, label = batch\n if cuda:\n data = data.cuda()\n with torch.no_grad():\n embeds = self.cnn(data)\n embed_matrix[c:c + loader.batch_size, :] = embeds # (batch_size, d)\n count += loader.batch_size\n c += loader.batch_size\n return embed_matrix, count\n\n def images_embed_calculator(self):\n action = 'test'\n classes = np.array([])\n if osp.exists(self.images_embed_path) and True:\n embeds_matrix = np.load(self.images_embed_path, allow_pickle=True)\n dict_image_class = np.load(self.dict_image_class_path, allow_pickle=True).item()\n dict_image_embed = np.load(self.dict_image_embed_path, allow_pickle=True).item()\n else:\n count = 0\n for i, name in enumerate(\n chain(self.dict_class_name[self.unseen_classes], self.dict_class_name[self.seen_classes])):\n dataset = ImageFolder(osp.join(self.data_path, 'images'), [name], f'{action}')\n embed_matrix = torch.tensor(np.zeros((len(dataset), 2048)))\n classes = np.concatenate((classes, np.repeat(name, len(dataset))))\n embed_matrix, count = self.one_class_images_embed(dataset, embed_matrix, count)\n b = np.array(dataset.data).T[0]\n im = np.array([item.split('/')[-1].split('.')[0] for item in b])\n if i == 0:\n embeds_matrix = embed_matrix\n ims = im\n else:\n embeds_matrix = torch.cat((embeds_matrix, embed_matrix), 1)\n ims = np.concatenate((ims, im))\n dict_image_class = dict(zip(ims, classes))\n dict_image_embed = dict(zip(ims, embeds_matrix.numpy()))\n np.save(self.images_embed_path, embeds_matrix)\n np.save(self.dict_image_class_path, dict_image_class)\n np.save(self.dict_image_embed_path, dict_image_embed)\n return embeds_matrix, dict_image_embed, dict_image_class\n\n\nclass Awa2GraphCreator:\n def __init__(self, embed_matrix, dict_image_embed, dict_name_class, dict_idx_image_class, images_nodes_percentage,\n args):\n self.image_graph_path = 'save_data_graph/awa2/image_graph.gpickle'\n self.pre_knowledge_graph_path = 'materials/imagenet-induced-graph.json'\n self.knowledge_graph_path = 'save_data_graph/awa2/knowledge_graph.gpickle'\n self.dict_wnids_class_translation = dict_name_class\n self.embeddings = normalize(embed_matrix, norm='l2', axis=0)\n self.dict_image_embed = dict_image_embed\n self.images = list(dict_image_embed.keys())\n self.dict_idx_image_class = dict_idx_image_class\n self.images_nodes_percentage = images_nodes_percentage\n self.args = args\n\n def index_embed_transform(self):\n dict_index_embed = {i: item for i, item in enumerate(self.images)}\n dict_embed_index = {item: i for i, item in enumerate(self.images)}\n return dict_index_embed, dict_embed_index\n\n def create_image_graph(self):\n if osp.exists(self.image_graph_path) and True:\n image_gnx = nx.read_gpickle(self.image_graph_path)\n else:\n image_gnx = nx.Graph()\n kdt = KDTree(self.embeddings, leaf_size=40)\n # image_graph.add_nodes_from(np.arange(len(self.embeddings)))\n count = 0\n for i in range(len(self.embeddings)):\n neighbors, distances = kdt.query_radius(self.embeddings[i:i + 1], r=self.args.images_threshold,\n return_distance=True)\n if len(neighbors[0]) == 1:\n distances, neighbors = kdt.query(self.embeddings[i:i + 1], k=2,\n return_distance=True)\n neighbors, distances = neighbors[0], distances[0]\n loop_ind = np.where(distances == 0)\n if len(loop_ind[0]) > 1:\n loop_ind = np.where(neighbors == i)\n neighbors = np.delete(neighbors, loop_ind)\n distances = np.delete(distances, loop_ind)\n # make distance into weights and fix zero distances\n edges_weights = [1 / dist if dist > 0 else 1000 for dist in distances]\n len_neigh = len(neighbors)\n count += len_neigh\n mean = count / (i + 1)\n if i % 1000 == 0:\n print('Progress:', i, '/', len(self.embeddings), '; Current Mean:', mean) # 37273\n weight_edges = list(zip(np.repeat(i, len(neighbors)).astype(str), neighbors.astype(str), edges_weights))\n image_gnx.add_weighted_edges_from(weight_edges)\n nx.write_gpickle(image_gnx, self.image_graph_path)\n return image_gnx\n\n def imagenet_knowledge_graph(self):\n graph = json.load(open(self.pre_knowledge_graph_path, 'r'))\n edges = graph['edges']\n nodes = graph['wnids']\n # dict_nodes_translation = {i: node for i, node in enumerate(nodes)}\n dict_class_nodes_translation = {node: 'c' + str(i) for i, node in enumerate(nodes)}\n dict_nodes_class_translation = {'c' + str(i): node for i, node in enumerate(nodes)}\n dict_class_nodes_translation = {dict_class_nodes_translation, dict_nodes_class_translation}\n # edges = [(dict_nodes_translation[x[0]],\n # dict_nodes_translation[x[1]]) for x in edges]\n edges = [('c' + str(x[0]), 'c' + str(x[1])) for x in edges]\n kg_imagenet = nx.Graph()\n kg_imagenet.add_edges_from(edges)\n return kg_imagenet, dict_class_nodes_translation\n\n def attributed_graph(self, kg_imagenet, att_weight):\n graph = json.load(open(self.pre_knowledge_graph_path, 'r'))\n nodes = graph['wnids']\n all_attributes = graph['vectors']\n dict_class_nodes = {node: i for i, node in enumerate(nodes)}\n dict_nodes_class = {i: node for i, node in enumerate(nodes)}\n dict_class_nodes_translation = {dict_class_nodes, dict_nodes_class}\n awa2_split = json.load(open('materials/awa2-split.json', 'r'))\n seen_classes = awa2_split['train']\n unseen_classes = awa2_split['test']\n s_u_classes = seen_classes + unseen_classes\n s_u_idx = [dict_class_nodes_translation[c] for c in s_u_classes]\n kd_idx_to_class_idx = {i: dict_class_nodes_translation[c] for i, c in enumerate(s_u_idx)}\n attributes = np.array([all_attributes[idx] for idx in s_u_idx])\n attributes = normalize(attributes, norm='l2', axis=1)\n kdt = KDTree(attributes, leaf_size=10)\n # image_graph.add_nodes_from(np.arange(len(self.embeddings)))\n count = 0\n for i in range(len(attributes)):\n neighbors, distances = kdt.query_radius(attributes[i:i + 1], r=1.15,\n return_distance=True)\n if len(neighbors[0]) == 1:\n distances, neighbors = kdt.query(attributes[i:i + 1], k=2,\n return_distance=True)\n neighbors, distances = neighbors[0], distances[0]\n loop_ind = np.where(distances == 0)\n if len(loop_ind[0]) > 1:\n loop_ind = np.where(neighbors == i)\n neighbors = np.delete(neighbors, loop_ind)\n distances = np.delete(distances, loop_ind)\n # make distance into weights and fix zero distances\n edges_weights = [float(att_weight) / dist if dist > 0 else 1000 for dist in distances]\n len_neigh = len(neighbors)\n if len_neigh == 0:\n print('hi Im number ' + str(i))\n count += len_neigh\n mean = count / (i + 1)\n if i % 10 == 0:\n print('Progress:', i, '/', len(attributes), '; Current Mean:', mean) # 37273\n neighbors_translation = [dict_class_nodes_translation[kd_idx_to_class_idx[neighbor]] for neighbor in\n neighbors]\n weight_edges = list(zip(np.repeat(dict_class_nodes_translation[kd_idx_to_class_idx[i]], len(neighbors)),\n neighbors_translation, edges_weights))\n kg_imagenet.add_weighted_edges_from(weight_edges)\n # TODO: add the weight from the attributes to the pre graph and not replace them\n # (minor problem because it is sparse graph)\n largest_cc = max(nx.connected_components(kg_imagenet), key=len)\n kg_imagenet = kg_imagenet.subgraph(largest_cc).copy()\n return kg_imagenet\n\n def awa2_knowledge_graph(self):\n kg_imagenet = self.imagenet_knowledge_graph()\n awa2_split = json.load(open('materials/awa2-split.json', 'r'))\n train_wnids = awa2_split['train']\n test_wnids = awa2_split['test']\n relevant_nodes = list(chain(train_wnids, test_wnids))\n kg_awa2 = kg_imagenet.subgraph(relevant_nodes)\n return kg_awa2\n\n def create_labels_graph(self, dict_class_nodes_translation):\n labels_graph = nx.Graph()\n edges = np.array([(key, dict_class_nodes_translation[self.dict_idx_image_class[key]])\n for key in list(self.dict_idx_image_class.keys())]).astype(str)\n labels_graph.add_edges_from(edges)\n return labels_graph\n\n def weighted_graph(self, images_gnx, knowledge_graph, labels_graph, weights_dict):\n weighted_graph = nx.Graph()\n classes_nodes = knowledge_graph.nodes\n images_nodes = images_gnx.nodes\n labels_edges = labels_graph.edges\n images_edges = images_gnx.edges\n classes_edges = knowledge_graph.edges\n weighted_graph.add_nodes_from(images_nodes, key='movies')\n weighted_graph.add_nodes_from(classes_nodes, key='classes')\n # weighted_graph.add_edges_from(images_edges, key='images_edges')\n # weighted_graph.add_edges_from(classes_edges, key='classes_edges')\n # weighted_graph.add_edges_from(labels_edges, key='labels_edges')\n for edge in images_edges:\n dict_weight = images_gnx.get_edge_data(edge[0], edge[1])\n weight = dict_weight.get('weight')\n if weight is not None:\n weighted_graph.add_edge(edge[0], edge[1], weight=weight, key='images_edges')\n classes_weight = weights_dict['classes_edges']\n labels_weight = weights_dict['labels_edges']\n for edge in classes_edges:\n weighted_graph.add_edge(edge[0], edge[1], weight=classes_weight, key='images_edges')\n for edge in labels_edges:\n weighted_graph.add_edge(edge[0], edge[1], weight=labels_weight, key='labels_edges')\n images_nodes = np.array(images_nodes)\n random.Random(4).shuffle(images_nodes)\n classes_nodes = np.array(classes_nodes)\n random.Random(4).shuffle(classes_nodes)\n if self.images_nodes_percentage < 1:\n for image_node in images_nodes[0:int(len(images_nodes) * (1 - self.images_nodes_percentage))]:\n weighted_graph.remove_node(image_node)\n # for c in classes_nodes[0:int(len(classes_nodes) * 0.5)]:\n # weighted_graph.remove_node(c)\n return weighted_graph\n\n\ndef define_path(dataset_name):\n if dataset_name == \"awa2\":\n _data_path = 'ZSL _DataSets/awa2/Animals_with_Attributes2'\n _split_path = 'materials/awa2-split.json'\n _chkpt_path = \"save_data_graph/awa2\"\n elif dataset_name == \"cub\":\n _data_path = \"ZSL _DataSets/cub/CUB_200_2011\"\n _split_path = \"ZSL _DataSets/cub/CUB_200_2011/train_test_split_easy.mat\"\n _chkpt_path = 'save_data_graph/cub'\n elif dataset_name == \"lad\":\n _data_path = \"ZSL _DataSets/lad\"\n _split_path = \"ZSL _DataSets/lad/split_zsl.txt\"\n _chkpt_path = 'save_data_graph/lad'\n else:\n raise ValueError(\"Wrong dataset name: replace with awa2/cub/lad\")\n return _data_path, _split_path, _chkpt_path\n\nif __name__ == '__main__':\n cuda = torch.cuda.is_available()\n # cuda = False\n parser = argparse.ArgumentParser()\n parser.add_argument('--dataset', dest=\"dataset\", help=' Name of the dataset', type=str, default=\"awa2\")\n parser.add_argument('--cnn', default='materials/resnet50-base.pth')\n # parser.add_argument('--cnn', default='save_awa2/resnet-fit/epoch-1.pth')\n # parser.add_argument('--pred', default='save_awa2/gcn-dense-att/epoch-30.pred')\n # parser.add_argument('--pred', default='save_awa2/gcn-basic/epoch-34.pred')\n if cuda:\n parser.add_argument('--gpu', default='0')\n else:\n parser.add_argument('--gpu', default='-1')\n # parser.add_argument('--consider-trains', action='store_true')\n parser.add_argument('--consider-trains', action='store_false')\n\n parser.add_argument('--output', default=None)\n parser.add_argument('--images_threshold', default=0.10)\n parser.add_argument('--images_nodes_percentage', default=1)\n args = parser.parse_args()\n\n set_gpu(args.gpu)\n data_path, split_path, save_path = define_path(args.dataset)\n graph_preparation = ImagesEmbeddings(args, data_path, split_path, save_path)\n dict_name_class, dict_class_name = graph_preparation.dict_name_class, graph_preparation.dict_class_name\n seen_classes, unseen_classes = graph_preparation.seen_classes, graph_preparation.unseen_classes\n embeds_matrix, dict_image_embed, dict_image_class = graph_preparation.images_embed_calculator()\n # try:\n # dict_image_class_new = {image: dict_name_class[dict_image_class[image]]\n # for image in list(dict_image_class.keys())}\n # except:\n # dict_image_class_new = dict_image_class.copy()\n dict_idx_image_class = {i: dict_name_class[dict_image_class[image]]\n for i, image in enumerate(list(dict_image_class.keys()))}\n awa2_graph_creator = Awa2GraphCreator(embeds_matrix, dict_image_embed, dict_name_class, dict_idx_image_class,\n args.images_nodes_percentage, args)\n image_graph = awa2_graph_creator.create_image_graph()\n kg, dict_class_nodes_translation = awa2_graph_creator.imagenet_knowledge_graph()\n att_weight = 10\n kg = awa2_graph_creator.attributed_graph(kg, att_weight)\n seen_classes = [dict_class_nodes_translation[c] for c in seen_classes]\n unseen_classes = [dict_class_nodes_translation[c] for c in unseen_classes]\n split = {'seen': seen_classes, 'unseen': unseen_classes}\n labels_graph = awa2_graph_creator.create_labels_graph(dict_class_nodes_translation)\n weights = [1, 1]\n weights_dict = {'classes_edges': weights[0], 'labels_edges': weights[1]}\n awa2_graph = awa2_graph_creator.weighted_graph(image_graph, kg, labels_graph, weights_dict)\n print(len(image_graph.edges))\n print((len(image_graph.nodes)))\n print(len(kg.edges))\n print((len(kg.nodes)))\n print(len(labels_graph.edges))\n print((len(awa2_graph.edges)))\n" ]	[ [ "numpy.abs", "numpy.random.seed", "numpy.logspace", "numpy.subtract", "sklearn.metrics.pairwise.cosine_similarity", "numpy.ones", "numpy.concatenate", "numpy.argmax", "torch.cuda.is_available", "numpy.column_stack", "numpy.argsort", "numpy.repeat", "numpy.array", "numpy.zeros", "numpy.where", "matplotlib.pyplot.figure" ], [ "torch.load", "torch.cat", "torch.utils.data.DataLoader", "sklearn.neighbors.KDTree", "numpy.save", "numpy.concatenate", "sklearn.preprocessing.normalize", "numpy.delete", "torch.no_grad", "torch.cuda.is_available", "numpy.load", "numpy.array", "numpy.where" ] ]
HypnosPy/HypnosPy	[ "28b17d07ee78f7714bbbbd66f6253764addf9d94" ]	[ "healthyForce/MTLModels.py" ]	[ "import torch\nimport torch.nn as nn\nimport torch.optim as optim\nimport numpy as np\n\nclass MTL:\n def __init__(self):\n pass\n\n def aggregate_losses(self, losses):\n pass\n\n def adjust_after_validation(self, losses, epoch):\n pass\n\n\nclass MTLRandom(MTL):\n def __init__(self, ntasks, verbose=1):\n self.ntasks = ntasks\n\n def aggregate_losses(self, losses):\n return losses[np.random.randint(self.ntasks)]\n\n def adjust_after_validation(self, losses, epoch):\n return\n\n\nclass MTLUncertanty(MTL):\n\n def __init__(self, ntasks):\n\n super(MTLUncertanty, self).__init__()\n\n self.ntasks = ntasks\n # We have to be set in the Lightning Module\n #self.logsigma = nn.Parameter(torch.zeros(self.ntasks))\n self.logsigma = None\n\n def aggregate_losses(self, losses):\n \"\"\"\n Input: a list/set/dict of losses\n Output: a single value\n \"\"\"\n total_loss = 0\n for i, l in enumerate(losses):\n total_loss = total_loss + (l / (2. * torch.exp(self.logsigma[i])) + (self.logsigma[i]/2.))\n return total_loss\n\n def adjust_after_validation(self, losses, epoch):\n return\n\nclass MTLEqual(MTL):\n\n def __init__(self, ntasks):\n\n super(MTLEqual, self).__init__()\n self.ntasks = ntasks\n\n def aggregate_losses(self, losses):\n return sum(losses) / self.ntasks\n\n def adjust_after_validation(self, losses, epoch):\n return\n\nclass MTLDWA(MTL):\n\n def __init__(self, ntasks, algorithm, temperature=2, min_epochs_to_start=2, verbose=1):\n\n super(MTLDWA, self).__init__()\n self.ntasks = ntasks\n self.lambda_weight = torch.ones(self.ntasks)\n self.loss_t_1 = torch.ones(self.ntasks)\n self.loss_t_2 = torch.ones(self.ntasks)\n self.temperature = torch.ones(1) * temperature\n self.min_epochs_to_start = min_epochs_to_start\n\n self.algorithm = algorithm\n\n # Variables for ewa and trend version of DWA\n self.verbose = verbose\n self.max_epochs = 100\n self.history = torch.zeros(self.ntasks, self.max_epochs)\n self.winsize = 3\n\n #data = np.array([0,1,200,300,-10,20,10,-20,10,-20,1000])\n #ewma(data, 5, 0.9), trend(data[5:10])\n\n\n def aggregate_losses(self, losses):\n total_loss = 0\n #self.lambda_weight = self.lambda_weight.type_as(losses[0])\n for i, l in enumerate(losses):\n total_loss += (self.lambda_weight[i] * l)\n return total_loss / self.ntasks\n\n def adjust_after_validation(self, losses, epoch):\n\n for i in range(self.ntasks):\n self.loss_t_2[i] = self.loss_t_1[i]\n self.loss_t_1[i] = losses[i].item()\n\n if epoch >= self.min_epochs_to_start:\n\n if self.algorithm != \"default\":\n saved_from_epoch = epoch - self.min_epochs_to_start\n\n w = {}\n denominator = 0\n\n for i in range(self.ntasks):\n if self.algorithm == \"default\":\n w[i] = min(80., self.loss_t_1[i] / self.loss_t_2[i])\n else:\n self.history[i][saved_from_epoch] = min(80., self.loss_t_1[i] / self.loss_t_2[i])\n if self.algorithm == \"trend\":\n w[i] = trend(self.history[i][max(0, saved_from_epoch-self.winsize):saved_from_epoch])\n print(\"values:\", self.history[i][max(0, saved_from_epoch-self.winsize):saved_from_epoch])\n elif self.algorithm == \"ewma\":\n # Todo: need to implement a torch version of it\n w[i] = trend(self.history[i][max(0, saved_from_epoch-self.winsize):saved_from_epoch])\n\n if self.verbose > 0:\n print(\"w(%d) = %.4f\" % (i, w[i]))\n\n denominator += torch.exp(w[i]/self.temperature)\n\n for i in range(self.ntasks):\n numerator = self.ntasks * torch.exp(w[i]/self.temperature)\n self.lambda_weight[i] = numerator / denominator\n\n if self.verbose > 0:\n for i in range(self.ntasks):\n print(\"Lambda (%d) = %.4f\" % (i, self.lambda_weight[i]))\n\n\nclass MTLBandit(MTL):\n\n def __init__(self, ntasks,\n # \"bandit_alg_weight_assignment\"\n # algorithm: [ucb, ducb]\n # reward method: [l1/l2, l2/l1, l2-l1]\n # loss_assignment: [\"one\", \"priority\", \"all\"]\n strategy=\"bandit_ucb_l1l2_one\",\n min_epochs_to_start=2, verbose=1):\n\n super(MTLBandit, self).__init__()\n\n self.ntasks = ntasks\n\n self.bandit_alg = strategy.split(\"_\")[1]\n self.bandit_reward_method = strategy.split(\"_\")[2]\n self.bandit_loss_assignment = strategy.split(\"_\")[3]\n\n self.lambda_weight = torch.ones(self.ntasks)\n self.loss_t_1 = torch.ones(self.ntasks)\n self.loss_t_2 = torch.ones(self.ntasks)\n\n self.max_epochs = 100\n self.current_weight = torch.zeros(self.ntasks)\n self.reward = torch.zeros(self.max_epochs, self.ntasks)\n self.counts = torch.zeros(self.ntasks)\n self.chosen = torch.zeros(self.max_epochs, self.ntasks)\n\n self.gammas = torch.zeros(self.max_epochs) + 0.99\n\n self.min_epochs_to_start = min_epochs_to_start\n\n self.verbose = verbose\n\n def aggregate_losses(self, losses):\n total_loss = 0\n for i, l in enumerate(losses):\n total_loss += ((self.lambda_weight[i] * l) / self.ntasks)\n return total_loss\n\n def adjust_after_validation(self, losses, epoch):\n\n print(\"Current epoch:\", epoch)\n\n selected_task_i = -1\n\n for i in range(self.ntasks):\n self.loss_t_2[i] = self.loss_t_1[i]\n self.loss_t_1[i] = losses[i].item()\n\n if self.bandit_reward_method == \"l1l2\":\n self.reward[epoch][i] = min(80., self.loss_t_1[i] / self.loss_t_2[i])\n elif self.bandit_reward_method == \"l2l1\":\n self.reward[epoch][i] = min(80., self.loss_t_2[i] / self.loss_t_1[i])\n elif self.bandit_reward_method == \"l2-l1\":\n self.reward[epoch][i] = min(80., self.loss_t_2[i] - self.loss_t_1[i])\n\n if epoch >= self.min_epochs_to_start:\n\n if self.bandit_alg == \"ducb\":\n t_minus_s = get_t_minus_s(self.max_epochs, epoch)\n discount = self.gammas ** t_minus_s\n n_t_gamma = 0\n for i in range(self.ntasks):\n n_t_gamma += (discount * self.chosen[:, i]).sum()\n\n\n # TODO: I could replace this 'for' by a vectorized operation.\n for i in range(self.ntasks):\n # UBC1\n if self.bandit_alg == \"ucb\":\n\n avg_reward = (self.chosen[:, i] * self.reward[:, i]).sum() / self.chosen[:, i].sum()\n padding = np.sqrt(2.0 * np.log(epoch+1) / (1 + self.counts[i]))\n self.current_weight[i] = avg_reward + padding\n\n # discounted UBC -- very inefficient. Needs improvement\n elif self.bandit_alg == \"ducb\":\n\n N_t_gamma = (discount * self.chosen[:, i]).sum()\n avg_reward = (discount * self.reward[:, i]).sum() / N_t_gamma\n\n padding = 2.0 * np.sqrt(np.log(n_t_gamma)/N_t_gamma)\n\n self.current_weight[i] = avg_reward + padding\n\n else:\n print(\"Unkonwn bandit algorithm %s. Options are 'ubc' and 'ducb'\" % (self.bandit_alg))\n\n\n if self.verbose > 0:\n print(\"Current Reward(%d): %.3f (%.3f + %.3f)\" % (i,\n self.current_weight[i],\n avg_reward,\n padding\n )\n )\n selected_task_i = torch.argmax(self.current_weight).item()\n self.counts[selected_task_i] += 1\n self.chosen[epoch][selected_task_i] = 1\n\n if self.bandit_loss_assignment == \"all\":\n for x in range(self.ntasks):\n self.lambda_weight[x] = self.current_weight[x]\n\n elif self.bandit_loss_assignment in [\"one\", \"priority\"]:\n self.lambda_weight[selected_task_i] = 1\n for task_j in range(self.ntasks):\n if task_j != selected_task_i:\n if self.bandit_loss_assignment == \"priority\":\n self.lambda_weight[task_j] = 0.5\n else:\n self.lambda_weight[task_j] = 0.0\n\n else:\n # In case the algorithm has not started yet, we are \"choosing\" all arms\n for x in range(self.ntasks):\n self.chosen[epoch][x] = 1\n\n\n if self.verbose > 0:\n print(\"Selected Task:\", selected_task_i)\n for i in range(self.ntasks):\n print(\"W(%d): %.3f, Counts(%d): %d\" % (i, self.current_weight[i], i, self.counts[i]))\n for i in range(self.ntasks):\n print(\"Lambdas (%d) = %.4f\" % (i, self.lambda_weight[i]))\n" ]	[ [ "numpy.log", "torch.ones", "torch.zeros", "torch.argmax", "torch.exp", "numpy.random.randint" ] ]
raphaelchaves/transitionMatrix	[ "6ac54c8c6ce15dc81aa5e894cfcfabb127634b33" ]	[ "examples/python/matrix_from_duration_data.py" ]	[ "# encoding: utf-8\n\n# (c) 2017-2020 Open Risk, all rights reserved\n#\n# TransitionMatrix is licensed under the Apache 2.0 license a copy of which is included\n# in the source distribution of TransitionMatrix. This is notwithstanding any licenses of\n# third-party software included in this distribution. You may not use this file except in\n# compliance with the License.\n#\n# Unless required by applicable law or agreed to in writing, software distributed under\n# the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n# either express or implied. See the License for the specific language governing permissions and\n# limitations under the License.\n\n\n\"\"\"\nExample workflows using transitionMatrix to estimate a matrix from duration type data\nThe datasets are produced in examples/generate_synthetic_data.py\n\n\"\"\"\n\nimport pandas as pd\n\nimport transitionMatrix as tm\nfrom transitionMatrix import source_path\nfrom transitionMatrix.estimators import cohort_estimator as es\n\ndataset_path = source_path + \"datasets/\"\n\n# Select the example to run\n# 1-> An example with limited data (dataset contains only one entity)\n# 2-> A full example with a 2x2 matrix\n# 3-> A full example with a 8x8 matrix\n\nexample = 3\n\nif example == 1:\n\n # An example with limited data (dataset contains only one entity)\n data = pd.read_csv(dataset_path + 'synthetic_data1.csv', dtype={'State': str})\n sorted_data = data.sort_values(['ID', 'Time'], ascending=[True, True])\n myState = tm.StateSpace([('0', \"A\"), ('1', \"B\"), ('2', \"C\"), ('3', \"D\")])\n print(\"> Validate data set\")\n print(myState.validate_dataset(dataset=sorted_data))\n # Bin the data into 5 intervals\n cohort_data, cohort_intervals = tm.utils.bin_timestamps(data, cohorts=5)\n myEstimator = es.CohortEstimator(states=myState, ci={'method': 'goodman', 'alpha': 0.05})\n labels = {'Timestamp': 'Cohort', 'State': 'State', 'ID': 'ID'}\n result = myEstimator.fit(cohort_data, labels=labels)\n # Check significance of some estimates\n # First period\n myEstimator.summary(k=0)\n # Last period\n myEstimator.summary(k=4)\n\nelif example == 2:\n\n # Step 1\n # Load the data set into a pandas frame\n # Make sure state is read as a string and not as integer\n # Second synthetic data example:\n # n entities with ~10 observations each, [0,1] state, 50%/50% transition matrix\n print(\"> Step 1: Load the data\")\n data = pd.read_csv(dataset_path + 'synthetic_data2.csv', dtype={'State': str})\n sorted_data = data.sort_values(['ID', 'Time'], ascending=[True, True])\n print(sorted_data.describe())\n\n # Step 2\n # Describe and validate the State Space against the data\n print(\"> Step 2: Validate against state space\")\n myState = tm.StateSpace([('0', \"Basic\"), ('1', \"Default\")])\n myState.describe()\n print(myState.validate_dataset(dataset=sorted_data))\n\n # Step 3\n # Arrange the data in period cohorts\n print(\"> Step 3: Arrange the data in period cohorts\")\n cohort_data, cohort_intervals = tm.utils.bin_timestamps(data, cohorts=5)\n\n # Step 4\n # Estimate matrices using method of choice\n # compute confidence interval using goodman method at 95% confidence level\n print(\"> Step 4: Estimate matrices\")\n myEstimator = es.CohortEstimator(states=myState, ci={'method': 'goodman', 'alpha': 0.05})\n labels = {'Timestamp': 'Cohort', 'State': 'State', 'ID': 'ID'}\n result = myEstimator.fit(cohort_data, labels=labels)\n\n # Step 5\n # Print out the set of estimated matrices\n print(\"> Step 5: Display results\")\n myMatrixSet = tm.TransitionMatrixSet(values=result, temporal_type='Incremental')\n print(myMatrixSet.temporal_type)\n myMatrixSet.print_matrix()\n\n\nelif example == 3:\n\n data = pd.read_csv(dataset_path + 'synthetic_data3.csv', dtype={'State': str})\n sorted_data = data.sort_values(['ID', 'Time'], ascending=[True, True])\n myState = tm.StateSpace([('0', \"A\"), ('1', \"B\"), ('2', \"C\"), ('3', \"D\"), ('4', \"E\"), ('5', \"F\"), ('6', \"G\")])\n print(myState.validate_dataset(dataset=sorted_data))\n cohort_data, cohort_intervals = tm.utils.bin_timestamps(data, cohorts=5)\n myEstimator = es.CohortEstimator(states=myState, ci={'method': 'goodman', 'alpha': 0.05})\n labels = {'Timestamp': 'Cohort', 'State': 'State', 'ID': 'ID'}\n result = myEstimator.fit(cohort_data, labels=labels)\n myMatrixSet = tm.TransitionMatrixSet(values=result, temporal_type='Incremental')\n myMatrixSet.print_matrix()\n" ]	[ [ "pandas.read_csv" ] ]
karino2/Pytorch-Handwritten-Mathematical-Expression-Recognition	[ "6c6139624c71fa68a0a386a94346cfab39d0f087" ]	[ "Train.py" ]	[ "'''\nPython 3.6 \nPytorch 0.4\nWritten by Hongyu Wang in Beihang university\n'''\nimport torch\nimport math\nimport torch.nn as nn\nfrom torch.autograd import Variable\nimport torch.nn.functional as F\nimport numpy\nimport torch.utils.data as data\nfrom data_iterator import dataIterator\nfrom Densenet_torchvision import densenet121\nfrom Attention_RNN import AttnDecoderRNN\nimport random\n\n# compute the wer loss\ndef cmp_result(label,rec):\n dist_mat = numpy.zeros((len(label)+1, len(rec)+1),dtype='int32')\n dist_mat[0,:] = range(len(rec) + 1)\n dist_mat[:,0] = range(len(label) + 1)\n for i in range(1, len(label) + 1):\n for j in range(1, len(rec) + 1):\n hit_score = dist_mat[i-1, j-1] + (label[i-1] != rec[j-1])\n ins_score = dist_mat[i,j-1] + 1\n del_score = dist_mat[i-1, j] + 1\n dist_mat[i,j] = min(hit_score, ins_score, del_score)\n dist = dist_mat[len(label), len(rec)]\n return dist, len(label)\n\ndef load_dict(dictFile):\n fp=open(dictFile)\n stuff=fp.readlines()\n fp.close()\n lexicon={}\n for l in stuff:\n w=l.strip().split()\n lexicon[w[0]]=int(w[1])\n print('total words/phones',len(lexicon))\n return lexicon\n\ndatasets=['./offline-train.pkl','./train_caption.txt']\nvalid_datasets=['./offline-test.pkl', './test_caption.txt']\ndictionaries=['./dictionary.txt']\nbatch_Imagesize=500000\nvalid_batch_Imagesize=500000\nbatch_size=1\nmaxlen=48\nmaxImagesize= 100000\nhidden_size = 256\nteacher_forcing_ratio = 0.5\n\nworddicts = load_dict(dictionaries[0])\nworddicts_r = [None] * len(worddicts)\nfor kk, vv in worddicts.items():\n worddicts_r[vv] = kk\n\n#load train data and test data\ntrain,train_label = dataIterator(\n datasets[0], datasets[1],worddicts,batch_size=batch_size,\n batch_Imagesize=batch_Imagesize,maxlen=maxlen,maxImagesize=maxImagesize\n )\nlen_train = len(train)\n\ntest,test_label = dataIterator(\n valid_datasets[0],valid_datasets[1],worddicts,batch_size=batch_size,\n batch_Imagesize=batch_Imagesize,maxlen=maxlen,maxImagesize=maxImagesize\n )\n\n\nclass custom_dset(data.Dataset):\n def __init__(self,train,train_label):\n self.train = train\n self.train_label = train_label\n\n def __getitem__(self, index):\n train_setting = torch.from_numpy(numpy.array(self.train[index]))\n label_setting = torch.from_numpy(numpy.array(self.train_label[index])).type(torch.LongTensor)\n\n size = train_setting.size()\n train_setting = train_setting.view(1,size[2],size[3])\n label_setting = label_setting.view(-1)\n return train_setting,label_setting\n\n def __len__(self):\n return len(self.train)\n\noff_image_train = custom_dset(train,train_label)\noff_image_test = custom_dset(test,test_label)\n\n# collate_fn is writting for padding imgs in batch. But now, I used batch_size=1, so this function has no effect. \ndef collate_fn(batch):\n batch.sort(key=lambda x: len(x[1]), reverse=True)\n img, label = zip(batch)\n aa1 = 0\n bb1 = 0\n max_len = len(label[0])\n for j in range(len(img)):\n size = img[j].size()\n if size[1] > aa1:\n aa1 = size[1]\n if size[2] > bb1:\n bb1 = size[2]\n img_padding = torch.zeros(len(img),1,aa1,bb1).type(torch.FloatTensor)\n img_mask = torch.zeros(len(img),1,aa1,bb1).type(torch.FloatTensor)\n for ii in range (len(img)):\n size = img[ii].size()\n for ii1 in range (size[1]):\n for ii2 in range (size[2]):\n img_padding[ii][0][ii1][ii2] = img[ii][0][ii1][ii2]\n img_mask[ii][0][ii1][ii2] = 1\n img_padding = img_padding/255\n # img_padding_mask = torch.cat((img_padding,img_mask),1)\n\n label_padding = torch.zeros(len(label),max_len+1).type(torch.LongTensor)\n for i in range(len(label)):\n for i1 in range(len(label[i])):\n label_padding[i][i1] = label[i][i1]\n\n return img_padding, label_padding\n\ntrain_loader = torch.utils.data.DataLoader(\n dataset = off_image_train,\n batch_size = batch_size,\n shuffle = True,\n collate_fn = collate_fn,\n num_workers=8,\n )\ntest_loader = torch.utils.data.DataLoader(\n dataset = off_image_test,\n batch_size = batch_size,\n shuffle = True,\n collate_fn = collate_fn,\n num_workers=8,\n)\n\ndef my_train(target_length,attn_decoder1,\n output_highfeature, output_area,y,criterion,encoder_optimizer1,decoder_optimizer1,x_mean,dense_input):\n loss = 0\n\n # teacher_forcing is very useful in training RNN.\n use_teacher_forcing = True if random.random() < teacher_forcing_ratio else False\n\n decoder_input = Variable(torch.LongTensor([[111]]))\n decoder_input = decoder_input.cuda()\n decoder_hidden = attn_decoder1.initHidden()\n decoder_hidden = decoder_hiddenx_mean\n decoder_hidden = torch.tanh(decoder_hidden)\n attention_sum = Variable(torch.zeros(1,dense_input,output_area).cuda())\n decoder_attention = Variable(torch.zeros(1,dense_input,output_area).cuda())\n\n if use_teacher_forcing:\n encoder_optimizer1.zero_grad()\n decoder_optimizer1.zero_grad()\n my_num = 0\n\n for di in range(target_length):\n decoder_output, decoder_hidden, decoder_attention, attention_sum = attn_decoder1(decoder_input,\n decoder_hidden,\n output_highfeature,\n output_area,\n attention_sum,\n decoder_attention,\n dense_input)\n\n loss += criterion(decoder_output[0], y[:,di])\n my_num = my_num + 1\n if int(y[0][di]) == 0:\n break\n decoder_input = y[:,di]\n\n loss.backward()\n encoder_optimizer1.step()\n decoder_optimizer1.step()\n return loss.item()\n\n else:\n encoder_optimizer1.zero_grad()\n decoder_optimizer1.zero_grad()\n my_num = 0\n\n for di in range(target_length):\n decoder_output, decoder_hidden, decoder_attention,attention_sum= attn_decoder1(decoder_input, decoder_hidden,\n output_highfeature, output_area,\n attention_sum,decoder_attention,dense_input)\n #print(decoder_output.size()) 11112\n #print(y.size()) 137\n topv, topi = decoder_output[0][0].topk(1)\n decoder_input = topi\n loss += criterion(decoder_output[0], y[:,di])\n my_num = my_num + 1\n\n # if int(topi[0]) == 0:\n # break\n\n loss.backward()\n encoder_optimizer1.step()\n decoder_optimizer1.step()\n return loss.item()\n\n#encoder = DenseNet121().cuda()\nencoder = densenet121().cuda()\n\n\npthfile = r'densenet121-a639ec97.pth'\npretrained_dict = torch.load(pthfile) \nencoder_dict = encoder.state_dict()\npretrained_dict = {k: v for k, v in pretrained_dict.items() if k in encoder_dict}\nencoder_dict.update(pretrained_dict)\nencoder.load_state_dict(encoder_dict)\n\nattn_decoder1 = AttnDecoderRNN(hidden_size,112,dropout_p=0.2).cuda()\n# attn_pre = torch.load('model/attn_decoder_lr0.00009_nopadding_baseline.pkl')\n# attn_dict = attn_decoder1.state_dict()\n# attn_pre = {k: v for k, v in attn_pre.items() if k in attn_dict}\n# attn_dict.update(attn_pre)\n# attn_decoder1.load_state_dict(attn_dict)\n# encoder.load_state_dict(torch.load('model/encoder_lr0.00009_nopadding.pkl'))\n# attn_decoder1.load_state_dict(torch.load('model/attn_decoder_lr0.00009_nopadding.pkl'))\n\nlr_rate = 0.00009\nencoder_optimizer1 = torch.optim.Adam(encoder.parameters(), lr=lr_rate)\ndecoder_optimizer1 = torch.optim.Adam(attn_decoder1.parameters(), lr=lr_rate)\n\ncriterion = nn.CrossEntropyLoss()\nexprate = 0\n#encoder.load_state_dict(torch.load('model/encoder_lr0.00009_nopadding_pre_GN_te05_d02.pkl'))\n#attn_decoder1.load_state_dict(torch.load('model/attn_decoder_lr0.00009_nopadding_pre_GN_te05_d02.pkl'))\n\nfor epoch in range(1000):\n\n # if using SGD optimizer\n # if epoch%8 == 0:\n # lr_rate = lr_rate/10\n # encoder_optimizer1 = torch.optim.SGD(encoder.parameters(), lr=lr_rate,momentum=0.9)\n # decoder_optimizer1 = torch.optim.SGD(attn_decoder1.parameters(), lr=lr_rate,momentum=0.9)\n\n running_loss=0\n whole_loss = 0\n\n encoder.train(mode=True)\n attn_decoder1.train(mode=True)\n\n # this is the train\n for step,(x,y) in enumerate(train_loader):\n x = Variable(x.cuda())\n y = Variable(y.cuda())\n\n # out is CNN featuremaps\n out = encoder(x)\n output_highfeature = out.squeeze(0)\n\n x_mean = torch.mean(output_highfeature)\n x_mean = float(x_mean)\n\n # dense_input is height and output_area is width which is bb\n output_area1 = output_highfeature.size()\n output_area = output_area1[2]\n dense_input = output_area1[1]\n target_length = y.size()[1]\n\n running_loss += my_train(target_length,attn_decoder1,output_highfeature,\n output_area,y,criterion,encoder_optimizer1,decoder_optimizer1,x_mean,dense_input)\n\n \n if step % 100 == 99:\n pre = ((step+1)/len_train)100\n whole_loss += running_loss\n running_loss = running_loss/100\n print('epoch is %d, loading for %.3f%%, running_loss is %f' %(epoch,pre,running_loss))\n with open(\"training_data/running_loss_%.5f_pre_GN_te05_d02.txt\" %(lr_rate),\"a\") as f:\n f.write(\"%s\\n\"%(str(running_loss)))\n running_loss = 0\n\n loss_all_out = whole_loss / len_train\n print(\"epoch is %d, the whole loss is %f\" % (epoch, loss_all_out))\n with open(\"training_data/whole_loss_%.5f_pre_GN_te05_d02.txt\" % (lr_rate), \"a\") as f:\n f.write(\"%s\\n\" % (str(loss_all_out)))\n\n # this is the prediction and compute wer loss\n total_dist = 0\n total_label = 0\n total_line = 0\n total_line_rec = 0\n\n encoder.eval()\n attn_decoder1.eval()\n\n for step_t, (x_t, y_t) in enumerate(test_loader):\n x_t = Variable(x_t.cuda())\n y_t = Variable(y_t.cuda())\n out_t = encoder(x_t)\n output_highfeature_t = out_t.squeeze(0)\n x_mean_t = torch.mean(output_highfeature_t)\n x_mean_t = float(x_mean_t)\n output_area_t1 = output_highfeature_t.size()\n output_area_t = output_area_t1[2]\n dense_input = output_area_t1[1]\n target_length_t = y_t.size()[1]\n\n decoder_input_t = Variable(torch.LongTensor([[111]]))\n decoder_input_t = decoder_input_t.cuda()\n decoder_hidden_t = attn_decoder1.initHidden()\n decoder_hidden_t = decoder_hidden_t * x_mean_t\n decoder_hidden_t = torch.tanh(decoder_hidden_t)\n\n prediction = []\n label = []\n decoder_attention_t = Variable(torch.zeros(1,dense_input,output_area_t).cuda())\n attention_sum_t = Variable(torch.zeros(1,dense_input,output_area_t).cuda())\n for i in range(48):\n decoder_output, decoder_hidden_t, decoder_attention_t, attention_sum_t = attn_decoder1(decoder_input_t,\n decoder_hidden_t,\n output_highfeature_t,\n output_area_t,\n attention_sum_t,\n decoder_attention_t,dense_input)\n topv, topi = decoder_output[0].topk(1)\n decoder_input_t = topi\n\n # prediction\n prediction.append(int(topi[0]))\n if int(topi[0]) == 0:\n break\n # label\n for i_label in range(target_length_t):\n label.append(int(y_t[0][i_label]))\n #label.append(0)\n\n dist, llen = cmp_result(label, prediction)\n total_dist += dist\n total_label += llen\n total_line += 1\n if dist == 0:\n total_line_rec = total_line_rec+ 1\n\n print('total_line_rec is',total_line_rec)\n wer = float(total_dist) / total_label\n sacc = float(total_line_rec) / total_line\n print('wer is %.5f' % (wer))\n print('sacc is %.5f ' % (sacc))\n with open(\"training_data/wer_%.5f_pre_GN_te05_d02.txt\" % (lr_rate), \"a\") as f:\n f.write(\"%s\\n\" % (str(wer)))\n\n\n if (sacc > exprate):\n exprate = sacc\n print(exprate)\n print(\"saving the model....\")\n print('encoder_lr%.5f_nopadding_pre_GN_te05_d02_f.pkl' %(lr_rate))\n torch.save(encoder.state_dict(), 'model/encoder_lr%.5f_nopadding_pre_GN_te05_d02_f.pkl'%(lr_rate))\n torch.save(attn_decoder1.state_dict(), 'model/attn_decoder_lr%.5f_nopadding_pre_GN_te05_d02_f.pkl'%(lr_rate))\n print(\"done\")\n else:\n print('the best is %f' % (exprate))\n print('the loss is bigger than before,so do not save the model')\n\n\n\n\n\n\n\n\n\n\n" ]	[ [ "torch.mean", "torch.LongTensor", "torch.nn.CrossEntropyLoss", "torch.load", "torch.zeros", "torch.utils.data.DataLoader", "torch.tanh", "numpy.array" ] ]
PlusLabNLP/PredictiveEngagement	[ "214d3eb20901982d192b05b4d496420dfb273f8e" ]	[ "pytorch_src/engagement_classifier.py" ]	[ "import random\nimport numpy as np\nimport torch \nimport torch.optim as optim\nimport matplotlib.pyplot as plt\nfrom sklearn.metrics import classification_report, roc_auc_score\nimport pickle\nimport torch.nn as nn\nimport os \nimport csv\n\nrandom.seed(1000)\nnp.random.seed(1000)\ntorch.manual_seed(1000)\n# torch.backends.cudnn.benchmark = False\n# torch.backends.cudnn.deterministic = True\n# torch.backends.cudnn.enabled = False\n\nclass Engagement_cls():\n '''This class classifies each query and response pairs as 0(not engaging) or 1 (engaging)\n '''\n def __init__(self, train_dir, batch_size, mlp_hidden_dim, num_epochs,\\\n regularizer = 0.01, lr=1e-4, dropout = 0.1, optimizer=\"Adam\",\\\n ftrain_queries_embed=None, ftrain_replies_embed=None, fvalid_queries_embed=None, fvalid_replies_embed=None, ftest_queries_embed=None ,ftest_replies_embed=None):\n print('*************model parameters****************')\n print('mlp layers {}'.format(mlp_hidden_dim))\n print('learning rate {}'.format(lr))\n print('drop out rate {}'.format(dropout))\n print('batch size {}'.format(batch_size))\n print('optimizer {}'.format(optimizer))\n print('regularizer {}'.format(regularizer))\n print('***********************************************')\n print(ftrain_queries_embed)\n print(ftrain_replies_embed)\n print(fvalid_queries_embed)\n print(fvalid_replies_embed)\n print(ftest_queries_embed)\n print(ftest_replies_embed)\n\n self.train_dir = train_dir\n self.batch_size = batch_size\n self.mlp_hidden_dim = mlp_hidden_dim\n self.lr = lr\n self.dropout = dropout\n self.num_epochs = num_epochs\n self.optim = optimizer\n self.reg= regularizer\n self.ftrain_queries_embed = ftrain_queries_embed\n self.ftrain_replies_embed =ftrain_replies_embed\n self.fvalid_queries_embed= fvalid_queries_embed\n self.fvalid_replies_embed = fvalid_replies_embed\n self.ftest_queries_embed = ftest_queries_embed\n self.ftest_replies_embed = ftest_replies_embed\n\n def load_Bert_embeddings(self, data_dir, f_queries_embed, f_replies_embed):\n '''Load sentences Bert embeddings into dictionary \n '''\n print('Loading Bert embeddings of sentences')\n queries_vectors = {}\n replies_vectors = {}\n fwq = open(data_dir+f_queries_embed, 'rb')\n dict_queries = pickle.load(fwq)\n for query, embeds in dict_queries.items():\n queries_vectors[query] = embeds[0]\n\n fwr = open(data_dir + f_replies_embed, 'rb')\n dict_replies = pickle.load(fwr)\n for reply, embeds in dict_replies.items():\n replies_vectors[reply] = embeds[0]\n print('number of loaded embeddings is {} {}'.format(len(queries_vectors), len(replies_vectors)))\n return queries_vectors, replies_vectors\n \n \n def prepare_data(self, data_dir, ftrain=None, fvalid=None, ftest=None):\n '''Load train/valid/test utterance pairs and get their embeddings\n '''\n self.data_dir = data_dir \n if ftrain != None:\n csv_file = open(data_dir + ftrain)\n csv_reader_train = csv.reader(csv_file, delimiter=',')\n self.train_queries,self.train_replies,self.train_labels = [],[],[]\n next(csv_reader_train)\n for row in csv_reader_train:\n self.train_queries.append(row[1].split('\\n')[0])\n self.train_replies.append(row[2].split('\\n')[0])\n self.train_labels.append(int(row[3]))\n print('size of train_queries {}'.format(len(self.train_queries)))\n self.train_size = len(self.train_queries)\n self.train_queries_embeds, self.train_replies_embeds= self.load_Bert_embeddings(data_dir, self.ftrain_queries_embed, self.ftrain_replies_embed)\n\n if fvalid != None:\n csv_file = open(data_dir + fvalid)\n csv_reader_valid = csv.reader(csv_file, delimiter=',')\n self.valid_queries,self.valid_replies,self.valid_labels= [],[],[]\n next(csv_reader_valid)\n for row in csv_reader_valid:\n self.valid_queries.append(row[1].split('\\n')[0])\n self.valid_replies.append(row[2].split('\\n')[0])\n self.valid_labels.append(int(row[3]))\n print('size of valid_queries {}'.format(len(self.valid_queries)))\n self.valid_size = len(self.valid_queries)\n self.valid_queries_embeds, self.valid_replies_embeds= self.load_Bert_embeddings(data_dir, self.fvalid_queries_embed, self.fvalid_replies_embed)\n\n\n if ftest != None:\n print(self.ftest_queries_embed)\n print(self.ftest_replies_embed)\n csv_file = open(data_dir + ftest)\n csv_reader_test = csv.reader(csv_file, delimiter=',')\n\n self.test_queries,self.test_replies,self.test_labels = [],[],[]\n next(csv_reader_test)\n for row in csv_reader_test:\n self.test_queries.append(row[1].split('\\n')[0])\n self.test_replies.append(row[2].split('\\n')[0])\n self.test_labels.append(int(row[3]))\n self.test_size = len(self.test_queries)\n self.test_queries_embeds, self.test_replies_embeds= self.load_Bert_embeddings(data_dir, self.ftest_queries_embed, self.ftest_replies_embed)\n\n filename = self.train_dir + \"log_train.txt\"\n os.makedirs(os.path.dirname(filename), exist_ok=True)\n self.fw =open(filename, \"a\")\n self.fw.write('***********model parameters**************** \\n')\n self.fw.write('mlp layers {} \\n'.format(self.mlp_hidden_dim))\n self.fw.write('learning rate {}\\n'.format(self.lr))\n self.fw.write('drop out rate {}\\n'.format(self.dropout))\n self.fw.write('batch size {}\\n'.format(self.batch_size))\n self.fw.write('optimizer {}\\n'.format(self.optim))\n self.fw.write('regularizer {}'.format(self.reg))\n self.fw.write('***********************************************\\n')\n \n \n \n def shuffle_data(self, type='train'):\n '''Shuffle queries/replies/engagement scores for train/valid/test sets \n '''\n if type=='train':\n train_indexes = [i for i in range(self.train_size)] \n random.shuffle(train_indexes)\n shuffled_queries = []\n shuffled_replies = []\n shuffled_labels = []\n shuffled_replies_len = []\n shuffled_replies_num_diverse= []\n\n for i in train_indexes:\n shuffled_queries.append(self.train_queries[i]) \n shuffled_replies.append(self.train_replies[i])\n shuffled_labels.append(self.train_labels[i])\n\n self.train_queries = shuffled_queries\n self.train_replies = shuffled_replies\n self.train_labels = shuffled_labels\n\n elif type=='valid':\n valid_indexes = [i for i in range(self.valid_size)] \n random.shuffle(valid_indexes)\n shuffled_queries = []\n shuffled_replies = []\n shuffled_labels = []\n\n for i in valid_indexes:\n shuffled_queries.append(self.valid_queries[i]) \n shuffled_replies.append(self.valid_replies[i])\n shuffled_labels.append(self.valid_labels[i])\n\n self.valid_queries = shuffled_queries\n self.valid_replies = shuffled_replies\n self.valid_labels = shuffled_labels\n\n elif type=='test':\n test_indexes = [i for i in range(self.test_size)] \n random.shuffle(test_indexes)\n shuffled_queries = []\n shuffled_replies = []\n shuffled_labels = []\n\n for i in test_indexes:\n shuffled_queries.append(self.test_queries[i]) \n shuffled_replies.append(self.test_replies[i])\n shuffled_labels.append(self.test_labels[i])\n\n self.test_queries = shuffled_queries\n self.test_replies = shuffled_replies\n self.test_labels = shuffled_labels\n\n \n def train(self, early_stop=50, finetune=False):\n \n model = BiLSTM(mlp_hidden_dim=self.mlp_hidden_dim, dropout=self.dropout)\n if torch.cuda.is_available():\n model.cuda()\n max_auc = 0\n no_improve_epoch = 0\n no_improve_in_previous_epoch = False\n\n if finetune==False:\n model_name ='best_model' \n if finetune==True:\n model_name ='best_model_finetuned'\n #load pretrained model\n model.load_state_dict(torch.load(self.train_dir + 'best_model.pt'))\n info = torch.load(self.train_dir + 'best_model.info')\n print('the parameters of the best trained model is ')\n for name, param in model.named_parameters():\n if param.requires_grad:\n print (name, param.data, param.shape)\n print(self.lr)\n if self.optim=='SGD':\n optimizer = optim.SGD(model.parameters(), lr=self.lr, weight_decay=self.reg)\n if self.optim=='Adam':\n optimizer = optim.Adam(model.parameters(), lr=self.lr, weight_decay=self.reg)\n if self.optim=='RMSprop':\n optimizer = optim.RMSprop(model.parameters(), lr=self.lr, weight_decay=self.reg)\n\n plot_train_auc = []\n plot_valid_auc = []\n plot_valid_loss = []\n plot_train_loss = []\n plot_ep = []\n step=0\n #Shuffle valid data once since original file first has all the utterances with engagement score=0 and then all the utterances with engagement score=1\n self.shuffle_data('valid') \n\n for e in range(self.num_epochs):\n print('********************************************')\n print(e)\n if no_improve_in_previous_epoch:\n no_improve_epoch += 1\n if no_improve_epoch >= early_stop:\n break\n else:\n no_improve_epoch = 0\n no_improve_in_previous_epoch = True\n\n train_loss = []\n train_auc = []\n nonzero_total= 0\n list_preds = torch.tensor([self.train_size])\n list_grtuth = torch.tensor([self.train_size])\n if torch.cuda.is_available():\n list_preds = list_preds.cuda()\n list_grtuth = list_grtuth.cuda()\n self.shuffle_data('train')\n\n for stidx in range(0, self.train_size, self.batch_size):\n step+=1\n model.train()\n model.zero_grad()\n x_q = self.train_queries[stidx:stidx + self.batch_size]\n x_r = self.train_replies[stidx:stidx + self.batch_size]\n y = torch.tensor(self.train_labels[stidx:stidx + self.batch_size]).long()\n \n if torch.cuda.is_available():\n y = y.cuda()\n nonzero = torch.nonzero(y).size(0)\n nonzero_total +=nonzero\n model_output = model(x_q, x_r, self.train_queries_embeds, self.train_replies_embeds)\n\n pred_eval = torch.argmax(model_output, 1)\n \n\n list_preds = torch.cat((list_preds, pred_eval), dim=0)\n list_grtuth = torch.cat((list_grtuth, y), dim=0)\n \n #calculate weights for each class\n weight = torch.tensor([y.shape[0]/(2(y.shape[0]- nonzero)), y.shape[0]/(2nonzero)])\n if torch.cuda.is_available():\n weight = weight.cuda()\n #weighted loss function due bacuase of imbalanced data \n loss_function = nn.CrossEntropyLoss(weight)\n loss = loss_function(model_output, y)\n train_loss.append(loss.data) \n loss.backward()\n optimizer.step()\n print('number of nonzero in train is {}'.format(nonzero_total))\n #calculate the evaluation metric and loss value for train data\n train_auc = roc_auc_score(list_grtuth[1:].detach().cpu().numpy(), list_preds[1:].detach().cpu().numpy())\n train_loss = torch.mean(torch.stack(train_loss))\n # train_loss = np.mean(train_loss)\n \n #evaluate trained model on valid data\n val_loss = []\n val_auc = []\n nonzero_total = 0\n list_preds_v = torch.tensor([self.valid_size])\n list_grtuth_v = torch.tensor([self.valid_size])\n if torch.cuda.is_available():\n list_preds_v = list_preds_v.cuda()\n list_grtuth_v = list_grtuth_v.cuda()\n for stidx in range(0, self.valid_size, self.batch_size):\n model.eval()\n val_x_q = self.valid_queries[stidx:stidx + self.batch_size]\n val_x_r = self.valid_replies[stidx:stidx + self.batch_size]\n val_y = torch.tensor(self.valid_labels[stidx:stidx + self.batch_size]).long()\n \n if torch.cuda.is_available():\n val_y = val_y.cuda()\n nonzero = torch.nonzero(val_y).size(0)\n nonzero_total +=nonzero\n model_output = model(val_x_q, val_x_r, self.valid_queries_embeds, self.valid_replies_embeds)\n val_pred = torch.argmax(model_output, 1)\n list_preds_v = torch.cat((list_preds_v, val_pred), dim=0)\n list_grtuth_v = torch.cat((list_grtuth_v, val_y), dim=0)\n\n weight = torch.tensor([val_y.shape[0]/(2(val_y.shape[0]- nonzero)), val_y.shape[0]/(2nonzero)])\n if torch.cuda.is_available():\n weight = weight.cuda()\n loss_function = nn.CrossEntropyLoss(weight)\n v_loss = loss_function(model_output, val_y)\n\n val_loss.append(v_loss.data)\n\n val_auc = roc_auc_score(list_grtuth_v[1:].detach().cpu().numpy(), list_preds_v[1:].detach().cpu().numpy())\n # val_loss = np.mean(val_loss)\n val_loss = torch.mean(torch.stack(val_loss))\n\n print('number of nonzero in valid is {}'.format(nonzero_total))\n \n st_improv = ''\n if val_auc > max_auc:\n st_improv = ''\n torch.save({'step': step, 'epoch': e, 'train_loss': train_loss, 'train_auc': train_auc, 'val_loss': val_loss, 'val_auc': val_auc }, self.train_dir+model_name+'.info')\n torch.save(model.state_dict(), self.train_dir+model_name+'.pt')\n max_auc = val_auc\n no_improve_in_previous_epoch = False\n \n print('epcoh {:02} - train_loss {:.4f} - train_auc {:.4f} val_loss {:.4f} - val_auc {:.4f}{}'.format(\n e, train_loss, train_auc, val_loss, val_auc, st_improv))\n self.fw.write('epcoh {:02} - train_loss {:.4f} - train_auc {:.4f} val_loss {:.4f} - val_auc {:.4f}{} \\n'.format(\n e, train_loss, train_auc, val_loss, val_auc, st_improv))\n\n plot_train_auc.append(train_auc)\n plot_valid_auc.append(val_auc)\n plot_train_loss.append(train_loss)\n plot_valid_loss.append(val_loss)\n plot_ep.append(e)\n \n print('#############################################')\n model.load_state_dict(torch.load(self.train_dir + model_name+'.pt'))\n info = torch.load(self.train_dir + model_name+'.info')\n\n print('the parameters of the best trained model is ')\n for name, param in model.named_parameters():\n if param.requires_grad:\n print (name, param.data, param.shape)\n\n\n print('Done!')\n plt.figure(0) \n l1 = plt.plot(plot_ep,plot_train_auc,'-r', label='Train auc')\n l2 = plt.plot(plot_ep,plot_valid_auc,'-b', label='Valid auc')\n plt.legend(loc='upper left')\n plt.xlabel(\"train and valid acc for model\")\n plt.savefig(self.train_dir + 'model_auc.jpg')\n \n plt.figure(1) \n l1 = plt.plot(plot_ep,plot_train_loss,'-r', label='Train loss')\n l2 = plt.plot(plot_ep,plot_valid_loss,'-b', label='Valid loss')\n plt.legend(loc='upper left')\n plt.xlabel(\"train and valid loss for model\")\n plt.savefig(self.train_dir + 'model_loss.jpg')\n\n \n\n \n def test(self, fname):\n '''Test the trained model on test set\n '''\n if not os.path.isfile(self.train_dir+'best_model.pt'):\n print('There is not any trained model to be tested!\\nPlease first try to train the model.')\n return \n\n model = BiLSTM(mlp_hidden_dim=self.mlp_hidden_dim, dropout=self.dropout)\n if torch.cuda.is_available():\n model.cuda()\n model.load_state_dict(torch.load(self.train_dir+'best_model.pt'))\n info = torch.load(self.train_dir + 'best_model.info')\n model.eval()\n print('begining of test')\n for name, param in model.named_parameters():\n if param.requires_grad:\n print (name, param.data, param.shape)\n\n self.shuffle_data('test') \n test_loss = []\n test_auc = []\n nonzero_total= 0\n step = 0\n list_preds_t = torch.tensor([self.test_size])\n list_grtuth_t = torch.tensor([self.test_size])\n if torch.cuda.is_available():\n list_preds_t = list_preds_t.cuda()\n list_grtuth_t = list_grtuth_t.cuda()\n for stidx in range(0, self.test_size, self.batch_size):\n step+=1\n x_q = self.test_queries[stidx:stidx + self.batch_size]\n x_r = self.test_replies[stidx:stidx + self.batch_size]\n y = torch.tensor(self.test_labels[stidx:stidx + self.batch_size]).long()\n if torch.cuda.is_available():\n y = y.cuda()\n nonzero = torch.nonzero(y).size(0)\n nonzero_total +=nonzero\n model_output = model(x_q, x_r, self.test_queries_embeds, self.test_replies_embeds)\n pred_eval = torch.argmax(model_output, 1)\n list_preds_t = torch.cat((list_preds_t, pred_eval), dim=0)\n list_grtuth_t = torch.cat((list_grtuth_t, y), dim=0)\n print('batch {} has {} nonzero points and {} zero points overall {} points '.format(step, nonzero, y.shape[0]- nonzero, y.shape[0]))\n weight = torch.tensor([y.shape[0]/(2(y.shape[0]- nonzero)), y.shape[0]/(2nonzero)])\n if torch.cuda.is_available():\n weight = weight.cuda()\n loss_function = nn.CrossEntropyLoss(weight)\n loss = loss_function(model_output, y)\n test_loss.append(loss.data) \n print('number of nonzero in test is {}'.format(nonzero_total))\n\n test_auc = roc_auc_score(list_grtuth_t[1:].detach().cpu().numpy(), list_preds_t[1:].detach().cpu().numpy())\n print(classification_report(list_grtuth_t[1:].detach().cpu().numpy(), list_preds_t[1:].detach().cpu().numpy()))\n # test_loss = np.mean(test_loss)\n test_loss = torch.mean(torch.stack(test_loss))\n\n print('Test set: test_loss: {} -- test_auc: {}'.format(test_loss, test_auc))\n\n\n def generate_eng_score(self, fname_ground_truth, ofile):\n '''for all pairs of queries and replies predicts engagement scores\n Params:\n fname_ground_truth: file includes the queries and their ground-truth replies\n foname: file includes the queries, ground truth replies, generated replies (from self.test_replies) and engagement_score of queries and generated replies with following format:\n query===groundtruth_reply===generated_reply===engagement_score of query and generated_reply\n\n '''\n\n if not os.path.isfile(self.train_dir+'best_model_finetuned.pt'):\n print('There is not any finetuned model on DD dataset to be used!\\nPlease first try to finetune trained model.')\n return\n model = BiLSTM(mlp_hidden_dim=self.mlp_hidden_dim, dropout=self.dropout)\n if torch.cuda.is_available():\n model.cuda()\n model.load_state_dict(torch.load(self.train_dir + 'best_model_finetuned.pt'))\n info = torch.load(self.train_dir + 'best_model_finetuned.info')\n model.eval()\n\n fw_pred_labels = open(self.data_dir + ofile, 'w')\n fr_groundtruth_replies = open(self.data_dir + fname_ground_truth, 'r')\n groundtruth_replies =fr_groundtruth_replies.readlines() \n\n print('begining of prediction')\n for name, param in model.named_parameters():\n if param.requires_grad:\n print (name, param.data, param.shape)\n for stidx in range(0, self.test_size, self.batch_size):\n x_q = self.test_queries[stidx:stidx + self.batch_size]\n x_r = self.test_replies[stidx:stidx + self.batch_size]\n x_groundtruth_r = groundtruth_replies[stidx:stidx + self.batch_size]\n model_output = model(x_q, x_r, self.test_queries_embeds, self.test_replies_embeds)\n pred_eng = torch.nn.functional.softmax(model_output, dim=1)\n for ind in range(len(x_q)):\n fw_pred_labels.write(x_q[ind]+'==='+x_groundtruth_r[ind].split('\\n')[0]+'==='+x_r[ind]+'==='+str(pred_eng[ind][1].item())+'\\n')\n \n print('The engagingness score for specified replies has been predicted!')\n\n\n def get_eng_score(self, query, q_embed, reply, r_embed, model):\n '''for a pair of query and reply predicts engagement scores\n Params:\n query: input query\n q_embed: embeddings of query\n reply: input reply\n r_embed: embeddings of reply\n \n '''\n if not os.path.isfile(self.train_dir+'best_model_finetuned.pt'):\n print('There is not any finetuned model on DD dataset to be used!\\nPlease first try to finetune trained model.')\n return\n \n model = BiLSTM(mlp_hidden_dim=self.mlp_hidden_dim, dropout=self.dropout)\n if torch.cuda.is_available():\n model.cuda()\n model.load_state_dict(torch.load(self.train_dir + 'best_model_finetuned.pt'))\n info = torch.load(self.train_dir + 'best_model_finetuned.info')\n model.eval()\n\n model_output = model(query, reply, q_embed, r_embed)\n pred_eng = torch.nn.functional.softmax(model_output, dim=1)\n return pred_eng\n\n \n \n\n\nclass BiLSTM(nn.Module):\n '''The engagement classification model is a three layer mlp classifier with having tanh as activation functions which takes the embeddings of query and reply as input and pass their average into the mlp classifier\n '''\n def __init__(self, mlp_hidden_dim=[128], dropout=0.2):\n super(BiLSTM, self).__init__()\n self.dropout = nn.Dropout(p=dropout)\n num_classes=2\n self.mlp_hidden_0 = nn.Linear(768, mlp_hidden_dim[0], bias=True)\n self.mlp_hidden_1 = nn.Linear(mlp_hidden_dim[0], mlp_hidden_dim[1], bias=True)\n self.mlp_hidden_2 = nn.Linear(mlp_hidden_dim[1], mlp_hidden_dim[2], bias=True)\n self.mlp_out = nn.Linear(mlp_hidden_dim[2], num_classes, bias=True)\n\n\n def forward(self, queries_input, replies_input, queries_embeds, replies_embeds):\n\n for ind, q in enumerate(queries_input):\n if q not in queries_embeds.keys():\n print('the query {} embedding has not been found in the embedding file'.format(q))\n X_q = torch.tensor([queries_embeds[q] for q in queries_input])\n\n for ind, r in enumerate(replies_input):\n if r not in replies_embeds.keys():\n print('the reply {} embedding has not been found in the embedding file'.format(r))\n X_r = torch.tensor([replies_embeds[r] for r in replies_input])\n \n if torch.cuda.is_available():\n X_q, X_r = X_q.cuda(), X_r.cuda()\n mlp_input=X_q.add(X_r)\n mlp_input = torch.div(mlp_input,2)\n\n mlp_h_0 = torch.tanh(self.mlp_hidden_0(mlp_input))\n mlp_h_0= self.dropout(mlp_h_0)\n \n mlp_h_1 = torch.tanh(self.mlp_hidden_1(mlp_h_0))\n mlp_h_1= self.dropout(mlp_h_1)\n\n mlp_h_2 = torch.tanh(self.mlp_hidden_2(mlp_h_1))\n mlp_h_2= self.dropout(mlp_h_2)\n\n mlp_out= self.mlp_out(mlp_h_2)\n return mlp_out\n" ]	[ [ "matplotlib.pyplot.legend", "torch.nn.functional.softmax", "torch.load", "torch.cat", "matplotlib.pyplot.plot", "torch.cuda.is_available", "torch.save", "torch.nn.Dropout", "torch.nn.CrossEntropyLoss", "torch.tensor", "torch.nonzero", "matplotlib.pyplot.figure", "torch.div", "matplotlib.pyplot.savefig", "torch.nn.Linear", "torch.stack", "numpy.random.seed", "torch.manual_seed", "matplotlib.pyplot.xlabel", "torch.argmax" ] ]
keshuichonglx/tatk	[ "7e8ad18ca98b105cb0168192bddf80b747067c1b" ]	[ "tatk/policy/rule/camrest/rule.py" ]	[ "# -- coding: utf-8 --\nimport torch\nfrom tatk.policy.policy import Policy\nfrom tatk.policy.rule.camrest.rule_based_camrest_bot import RuleBasedCamrestBot\nfrom tatk.policy.rule.camrest.policy_agenda_camrest import UserPolicyAgendaCamrest\n\nDEVICE = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n\nclass Rule(Policy):\n \n def __init__(self, is_train=False, character='sys'):\n self.is_train = is_train\n self.character = character\n\n if character == 'sys':\n self.policy = RuleBasedCamrestBot()\n elif character == 'usr':\n self.policy = UserPolicyAgendaCamrest()\n else:\n raise NotImplementedError('unknown character {}'.format(character))\n \n def predict(self, state):\n \"\"\"\n Predict an system action given state.\n Args:\n state (dict): Dialog state. Please refer to util/state.py\n Returns:\n action : System act, with the form of (act_type, {slot_name_1: value_1, slot_name_2, value_2, ...})\n \"\"\"\n return self.policy.predict(state)\n\n def init_session(self):\n \"\"\"\n Restore after one session\n \"\"\"\n self.policy.init_session()\n\n def is_terminated(self):\n if self.character == 'sys':\n return None\n return self.policy.is_terminated()\n\n def get_reward(self):\n if self.character == 'sys':\n return None\n return self.policy.get_reward()\n\n def get_goal(self):\n if hasattr(self.policy, 'get_goal'):\n return self.policy.get_goal()\n return None\n" ]	[ [ "torch.cuda.is_available" ] ]
lpierezan/cp_playground	[ "818d116391b762c1ca03be772a50bb997b7958a4" ]	[ "linalg/lu_decomp.py" ]	[ "import numpy as np\n\ndef lu_decomp(A):\n n = len(A)\n U = A.copy()\n L = np.eye(n)\n row_idx = list(range(n))\n\n for col in range(n):\n # find best row\n best_row, best_elem = None, None\n for row in range(col,n):\n row_i = row_idx[row]\n elem = U[row_i][col]\n if best_row is None or abs(elem) > best_elem:\n best_row = row\n best_elem = abs(elem)\n\n if best_elem == 0:\n #raise(Exception(\"Not full rank.\"))\n continue\n\n # swap rows: best_row and col\n L[row_idx[col]][col] = 0\n L[row_idx[col]][best_row] = 1\n L[row_idx[best_row]][best_row] = 0\n L[row_idx[best_row]][col] = 1\n row_idx[col], row_idx[best_row] = row_idx[best_row] , row_idx[col]\n best_row_i = row_idx[col]\n\n # normalize\n for row in range(col+1,n):\n row_i = row_idx[row]\n coef = U[row_i][col] / U[best_row_i][col]\n L[row_i][col] = coef\n U[row_i] = U[row_i] - U[best_row_i] * coef\n\n return L, U, row_idx\n\ndef solve_lu(L_,U_,p,b_):\n L = L_[p]\n U = U_[p]\n b = b_[p]\n\n n = len(L)\n z = np.zeros(n)\n x = np.zeros(n)\n \n # Lz = b\n # L[i,:i] * sum(z[:i,0] + z[i]) = b[i]\n for i in range(n):\n z[i] = b[i] - (L[i,:i] * z[:i]).sum()\n\n assert np.allclose(L.dot(z),b)\n\n # Ux = z\n # U[i,i] * x[i] + sum(U[i,i+1:] * x[i+1:]) = z[i]\n for i in range(n-1,-1,-1):\n acc = (z[i] - (U[i,i+1:] * x[i+1:]).sum())\n if(np.isclose(U[i,i], 0)):\n if(np.isclose(acc,0)):\n # multiple solutions\n x[i] = 0.0\n else:\n # no solution\n raise(Exception('no solution'))\n else:\n x[i] = acc / U[i,i]\n\n assert np.allclose(U.dot(x),z)\n\n return x\n\ndef test_lu():\n n_teste = 500\n np.random.seed(8)\n\n while(n_teste > 0):\n n_teste -= 1 \n n = np.random.randint(1,30)\n A = np.random.random((n,n))\n \n if(np.random.random() > 0.5):\n print('Not singular.')\n A[np.random.randint(0,n)] = np.random.uniform(0,100) * A[np.random.randint(0,n)]\n\n L, U, row_idx = lu_decomp(A)\n\n L = L[row_idx]\n U = U[row_idx]\n A = A[row_idx]\n\n assert np.allclose(L.dot(U).ravel(), A.ravel())\n \n print('LU decomposition Ok!')\n\ndef test_solve():\n np.random.seed(8)\n n_teste = 10\n while n_teste > 0:\n n_teste -= 1\n\n n = np.random.randint(1,100)\n A = np.random.random((n,n))\n b = np.random.random(n)\n\n #A[-1] = A[0]\n #b[-1] = b[0]\n \n ans_correct = np.linalg.solve(A,b)\n \n L,U,p = lu_decomp(A)\n ans = solve_lu(L,U,p,b)\n\n assert np.allclose(A.dot(ans), b)\n assert np.allclose(ans, ans_correct)\n \n print('Solve with LU Ok!')\n\nif __name__ == \"__main__\":\n test_lu()\n test_solve()\n\n \n \n\n\n\n" ]	[ [ "numpy.linalg.solve", "numpy.random.random", "numpy.allclose", "numpy.random.seed", "numpy.isclose", "numpy.eye", "numpy.random.uniform", "numpy.zeros", "numpy.random.randint" ] ]
kunalvats/featuretools	[ "25d8a36b7d636546161122095f5d6ca793a0b974" ]	[ "featuretools/computational_backends/pandas_backend.py" ]	[ "import cProfile\nimport logging\nimport os\nimport pstats\nimport sys\nimport warnings\nfrom datetime import datetime\n\nimport numpy as np\nimport pandas as pd\nimport pandas.api.types as pdtypes\nfrom future import standard_library\n\nfrom .base_backend import ComputationalBackend\nfrom .feature_tree import FeatureTree\n\nfrom featuretools import variable_types\nfrom featuretools.entityset.relationship import Relationship\nfrom featuretools.exceptions import UnknownFeature\nfrom featuretools.primitives import (\n AggregationPrimitive,\n DirectFeature,\n IdentityFeature,\n TransformPrimitive\n)\nfrom featuretools.utils.gen_utils import make_tqdm_iterator\n\nstandard_library.install_aliases()\nwarnings.simplefilter('ignore', np.RankWarning)\nwarnings.simplefilter(\"ignore\", category=RuntimeWarning)\nlogger = logging.getLogger('featuretools.computational_backend')\nROOT_DIR = os.path.expanduser(\"~\")\n\n\nclass PandasBackend(ComputationalBackend):\n\n def __init__(self, entityset, features):\n assert len(set(f.entity.id for f in features)) == 1, \\\n \"Features must all be defined on the same entity\"\n\n self.entityset = entityset\n self.target_eid = features[0].entity.id\n self.features = features\n self.feature_tree = FeatureTree(entityset, features)\n\n def __sizeof__(self):\n return self.entityset.__sizeof__()\n\n def calculate_all_features(self, instance_ids, time_last,\n training_window=None, profile=False,\n precalculated_features=None, ignored=None,\n verbose=False):\n \"\"\"\n Given a list of instance ids and features with a shared time window,\n generate and return a mapping of instance -> feature values.\n\n Args:\n instance_ids (list): List of instance id for which to build features.\n\n time_last (pd.Timestamp): Last allowed time. Data from exactly this\n time not allowed.\n\n training_window (Timedelta, optional): Data older than\n time_last by more than this will be ignored.\n\n profile (bool): Enable profiler if True.\n\n verbose (bool): Print output progress if True.\n\n Returns:\n pd.DataFrame : Pandas DataFrame of calculated feature values.\n Indexed by instance_ids. Columns in same order as features\n passed in.\n\n \"\"\"\n assert len(instance_ids) > 0, \"0 instance ids provided\"\n self.instance_ids = instance_ids\n\n self.time_last = time_last\n if self.time_last is None:\n self.time_last = datetime.now()\n\n # For debugging\n if profile:\n pr = cProfile.Profile()\n pr.enable()\n\n if precalculated_features is None:\n precalculated_features = {}\n # Access the index to get the filtered data we need\n target_entity = self.entityset[self.target_eid]\n if ignored:\n # TODO: Just want to remove entities if don't have any (sub)features defined\n # on them anymore, rather than recreating\n ordered_entities = FeatureTree(self.entityset, self.features, ignored=ignored).ordered_entities\n else:\n ordered_entities = self.feature_tree.ordered_entities\n\n necessary_columns = self.feature_tree.necessary_columns\n eframes_by_filter = \\\n self.entityset.get_pandas_data_slice(filter_entity_ids=ordered_entities,\n index_eid=self.target_eid,\n instances=instance_ids,\n entity_columns=necessary_columns,\n time_last=time_last,\n training_window=training_window,\n verbose=verbose)\n large_eframes_by_filter = None\n if any([f.uses_full_entity for f in self.feature_tree.all_features]):\n large_necessary_columns = self.feature_tree.necessary_columns_for_all_values_features\n large_eframes_by_filter = \\\n self.entityset.get_pandas_data_slice(filter_entity_ids=ordered_entities,\n index_eid=self.target_eid,\n instances=None,\n entity_columns=large_necessary_columns,\n time_last=time_last,\n training_window=training_window,\n verbose=verbose)\n\n # Handle an empty time slice by returning a dataframe with defaults\n if eframes_by_filter is None:\n return self.generate_default_df(instance_ids=instance_ids)\n\n finished_entity_ids = []\n # Populate entity_frames with precalculated features\n if len(precalculated_features) > 0:\n for entity_id, precalc_feature_values in precalculated_features.items():\n if entity_id in eframes_by_filter:\n frame = eframes_by_filter[entity_id][entity_id]\n eframes_by_filter[entity_id][entity_id] = pd.merge(frame,\n precalc_feature_values,\n left_index=True,\n right_index=True)\n else:\n # Only features we're taking from this entity\n # are precomputed\n # Make sure the id variable is a column as well as an index\n entity_id_var = self.entityset[entity_id].index\n precalc_feature_values[entity_id_var] = precalc_feature_values.index.values\n eframes_by_filter[entity_id] = {entity_id: precalc_feature_values}\n finished_entity_ids.append(entity_id)\n\n # Iterate over the top-level entities (filter entities) in sorted order\n # and calculate all relevant features under each one.\n if verbose:\n total_groups_to_compute = sum(len(group)\n for group in self.feature_tree.ordered_feature_groups.values())\n\n pbar = make_tqdm_iterator(total=total_groups_to_compute,\n desc=\"Computing features\",\n unit=\"feature group\")\n if verbose:\n pbar.update(0)\n\n for filter_eid in ordered_entities:\n entity_frames = eframes_by_filter[filter_eid]\n large_entity_frames = None\n if large_eframes_by_filter is not None:\n large_entity_frames = large_eframes_by_filter[filter_eid]\n\n # update the current set of entity frames with the computed features\n # from previously finished entities\n for eid in finished_entity_ids:\n # only include this frame if it's not from a descendent entity:\n # descendent entity frames will have to be re-calculated.\n # TODO: this check might not be necessary, depending on our\n # constraints\n if not self.entityset.find_backward_path(start_entity_id=filter_eid,\n goal_entity_id=eid):\n entity_frames[eid] = eframes_by_filter[eid][eid]\n # TODO: look this over again\n # precalculated features will only be placed in entity_frames,\n # and it's possible that that they are the only features computed\n # for an entity. In this case, the entity won't be present in\n # large_eframes_by_filter. The relevant lines that this case passes\n # through are 136-143\n if (large_eframes_by_filter is not None and\n eid in large_eframes_by_filter and eid in large_eframes_by_filter[eid]):\n large_entity_frames[eid] = large_eframes_by_filter[eid][eid]\n\n if filter_eid in self.feature_tree.ordered_feature_groups:\n for group in self.feature_tree.ordered_feature_groups[filter_eid]:\n if verbose:\n pbar.set_postfix({'running': 0})\n\n test_feature = group[0]\n entity_id = test_feature.entity.id\n\n input_frames_type = self.feature_tree.input_frames_type(test_feature)\n\n input_frames = large_entity_frames\n if input_frames_type == \"subset_entity_frames\":\n input_frames = entity_frames\n\n handler = self._feature_type_handler(test_feature)\n result_frame = handler(group, input_frames)\n\n output_frames_type = self.feature_tree.output_frames_type(test_feature)\n if output_frames_type in ['full_and_subset_entity_frames', 'subset_entity_frames']:\n index = entity_frames[entity_id].index\n # If result_frame came from a uses_full_entity feature,\n # and the input was large_entity_frames,\n # then it's possible it doesn't contain some of the features\n # in the output entity_frames\n # We thus need to concatenate the existing frame with the result frame,\n # making sure not to duplicate any columns\n _result_frame = result_frame.reindex(index)\n cols_to_keep = [c for c in _result_frame.columns\n if c not in entity_frames[entity_id].columns]\n entity_frames[entity_id] = pd.concat([entity_frames[entity_id],\n _result_frame[cols_to_keep]],\n axis=1)\n\n if output_frames_type in ['full_and_subset_entity_frames', 'full_entity_frames']:\n index = large_entity_frames[entity_id].index\n _result_frame = result_frame.reindex(index)\n cols_to_keep = [c for c in _result_frame.columns\n if c not in large_entity_frames[entity_id].columns]\n large_entity_frames[entity_id] = pd.concat([large_entity_frames[entity_id],\n _result_frame[cols_to_keep]],\n axis=1)\n\n if verbose:\n pbar.update(1)\n\n finished_entity_ids.append(filter_eid)\n\n if verbose:\n pbar.set_postfix({'running': 0})\n pbar.refresh()\n sys.stdout.flush()\n pbar.close()\n\n # debugging\n if profile:\n pr.disable()\n prof_folder_path = os.path.join(ROOT_DIR, 'prof')\n if not os.path.exists(prof_folder_path):\n os.mkdir(prof_folder_path)\n with open(os.path.join(prof_folder_path, 'inst-%s.log' %\n list(instance_ids)[0]), 'w') as f:\n pstats.Stats(pr, stream=f).strip_dirs().sort_stats(\"cumulative\", \"tottime\").print_stats()\n\n df = eframes_by_filter[self.target_eid][self.target_eid]\n\n # fill in empty rows with default values\n missing_ids = [i for i in instance_ids if i not in\n df[target_entity.index]]\n if missing_ids:\n default_df = self.generate_default_df(instance_ids=missing_ids,\n extra_columns=df.columns)\n df = df.append(default_df, sort=True)\n\n df.index.name = self.entityset[self.target_eid].index\n return df[[feat.get_name() for feat in self.features]]\n\n def generate_default_df(self, instance_ids, extra_columns=None):\n index_name = self.features[0].entity.index\n default_row = [f.default_value for f in self.features]\n default_cols = [f.get_name() for f in self.features]\n default_matrix = [default_row] * len(instance_ids)\n default_df = pd.DataFrame(default_matrix,\n columns=default_cols,\n index=instance_ids)\n default_df.index.name = index_name\n if extra_columns is not None:\n for c in extra_columns:\n if c not in default_df.columns:\n default_df[c] = [np.nan] * len(instance_ids)\n return default_df\n\n def _feature_type_handler(self, f):\n if isinstance(f, TransformPrimitive):\n return self._calculate_transform_features\n elif isinstance(f, DirectFeature):\n return self._calculate_direct_features\n elif isinstance(f, AggregationPrimitive):\n return self._calculate_agg_features\n elif isinstance(f, IdentityFeature):\n return self._calculate_identity_features\n else:\n raise UnknownFeature(u\"{} feature unknown\".format(f.__class__))\n\n def _calculate_identity_features(self, features, entity_frames):\n entity_id = features[0].entity.id\n assert (entity_id in entity_frames and\n features[0].get_name() in entity_frames[entity_id].columns)\n return entity_frames[entity_id]\n\n def _calculate_transform_features(self, features, entity_frames):\n entity_id = features[0].entity.id\n assert len(set([f.entity.id for f in features])) == 1, \\\n \"features must share base entity\"\n assert entity_id in entity_frames\n\n frame = entity_frames[entity_id]\n for f in features:\n # handle when no data\n if frame.shape[0] == 0:\n set_default_column(frame, f)\n continue\n\n # collect only the variables we need for this transformation\n variable_data = [frame[bf.get_name()].values\n for bf in f.base_features]\n\n feature_func = f.get_function()\n # apply the function to the relevant dataframe slice and add the\n # feature row to the results dataframe.\n if f.uses_calc_time:\n values = feature_func(variable_data, time=self.time_last)\n else:\n values = feature_func(variable_data)\n\n if isinstance(values, pd.Series):\n values = values.values\n frame[f.get_name()] = list(values)\n return frame\n\n def _calculate_direct_features(self, features, entity_frames):\n entity_id = features[0].entity.id\n parent_entity_id = features[0].parent_entity.id\n\n assert entity_id in entity_frames and parent_entity_id in entity_frames\n\n path = self.entityset.find_forward_path(entity_id, parent_entity_id)\n assert len(path) == 1, \\\n \"Error calculating DirectFeatures, len(path) > 1\"\n\n parent_df = entity_frames[parent_entity_id]\n child_df = entity_frames[entity_id]\n merge_var = path[0].child_variable.id\n\n # generate a mapping of old column names (in the parent entity) to\n # new column names (in the child entity) for the merge\n col_map = {path[0].parent_variable.id: merge_var}\n index_as_feature = None\n for f in features:\n if f.base_features[0].get_name() == path[0].parent_variable.id:\n index_as_feature = f\n # Sometimes entityset._add_multigenerational_links adds link variables\n # that would ordinarily get calculated as direct features,\n # so we make sure not to attempt to calculate again\n if f.get_name() in child_df.columns:\n continue\n col_map[f.base_features[0].get_name()] = f.get_name()\n\n # merge the identity feature from the parent entity into the child\n merge_df = parent_df[list(col_map.keys())].rename(columns=col_map)\n if index_as_feature is not None:\n merge_df.set_index(index_as_feature.get_name(), inplace=True,\n drop=False)\n else:\n merge_df.set_index(merge_var, inplace=True)\n\n new_df = pd.merge(left=child_df, right=merge_df,\n left_on=merge_var, right_index=True,\n how='left')\n\n return new_df\n\n def _calculate_agg_features(self, features, entity_frames):\n test_feature = features[0]\n entity = test_feature.entity\n child_entity = test_feature.base_features[0].entity\n\n assert entity.id in entity_frames and child_entity.id in entity_frames\n\n frame = entity_frames[entity.id]\n base_frame = entity_frames[child_entity.id]\n # Sometimes approximate features get computed in a previous filter frame\n # and put in the current one dynamically,\n # so there may be existing features here\n features = [f for f in features if f.get_name()\n not in frame.columns]\n if not len(features):\n return frame\n\n # handle where clause for all functions below\n where = test_feature.where\n if where is not None:\n base_frame = base_frame[base_frame[where.get_name()]]\n\n relationship_path = self.entityset.find_backward_path(entity.id,\n child_entity.id)\n\n groupby_var = Relationship._get_link_variable_name(relationship_path)\n\n # if the use_previous property exists on this feature, include only the\n # instances from the child entity included in that Timedelta\n use_previous = test_feature.use_previous\n if use_previous and not base_frame.empty:\n # Filter by use_previous values\n time_last = self.time_last\n if use_previous.is_absolute():\n time_first = time_last - use_previous\n ti = child_entity.time_index\n if ti is not None:\n base_frame = base_frame[base_frame[ti] >= time_first]\n else:\n n = use_previous.value\n\n def last_n(df):\n return df.iloc[-n:]\n\n base_frame = base_frame.groupby(groupby_var, observed=True, sort=False).apply(last_n)\n\n to_agg = {}\n agg_rename = {}\n to_apply = set()\n # apply multivariable and time-dependent features as we find them, and\n # save aggregable features for later\n for f in features:\n if _can_agg(f):\n variable_id = f.base_features[0].get_name()\n\n if variable_id not in to_agg:\n to_agg[variable_id] = []\n\n func = f.get_function()\n funcname = func\n if callable(func):\n funcname = func.__name__\n\n to_agg[variable_id].append(func)\n # this is used below to rename columns that pandas names for us\n agg_rename[u\"{}-{}\".format(variable_id, funcname)] = f.get_name()\n continue\n\n to_apply.add(f)\n\n # Apply the non-aggregable functions generate a new dataframe, and merge\n # it with the existing one\n if len(to_apply):\n wrap = agg_wrapper(to_apply, self.time_last)\n # groupby_var can be both the name of the index and a column,\n # to silence pandas warning about ambiguity we explicitly pass\n # the column (in actuality grouping by both index and group would\n # work)\n to_merge = base_frame.groupby(base_frame[groupby_var], observed=True, sort=False).apply(wrap)\n\n to_merge.reset_index(1, drop=True, inplace=True)\n frame = pd.merge(left=frame, right=to_merge,\n left_index=True,\n right_index=True, how='left')\n\n # Apply the aggregate functions to generate a new dataframe, and merge\n # it with the existing one\n if len(to_agg):\n # groupby_var can be both the name of the index and a column,\n # to silence pandas warning about ambiguity we explicitly pass\n # the column (in actuality grouping by both index and group would\n # work)\n to_merge = base_frame.groupby(base_frame[groupby_var],\n observed=True, sort=False).agg(to_agg)\n # rename columns to the correct feature names\n to_merge.columns = [agg_rename[\"-\".join(x)] for x in to_merge.columns.ravel()]\n to_merge = to_merge[list(agg_rename.values())]\n\n # workaround for pandas bug where categories are in the wrong order\n # see: https://github.com/pandas-dev/pandas/issues/22501\n if pdtypes.is_categorical_dtype(frame.index):\n categories = pdtypes.CategoricalDtype(categories=frame.index.categories)\n to_merge.index = to_merge.index.astype(object).astype(categories)\n\n frame = pd.merge(left=frame, right=to_merge,\n left_index=True, right_index=True, how='left')\n\n # Handle default values\n # 1. handle non scalar default values\n iterfeats = [f for f in features\n if hasattr(f.default_value, '__iter__')]\n for f in iterfeats:\n nulls = pd.isnull(frame[f.get_name()])\n for ni in nulls[nulls].index:\n frame.at[ni, f.get_name()] = f.default_value\n\n # 2. handle scalars default values\n fillna_dict = {f.get_name(): f.default_value for f in features\n if f not in iterfeats}\n frame.fillna(fillna_dict, inplace=True)\n\n # convert boolean dtypes to floats as appropriate\n # pandas behavior: https://github.com/pydata/pandas/issues/3752\n for f in features:\n if (not f.expanding and\n f.variable_type == variable_types.Numeric and\n frame[f.get_name()].dtype.name in ['object', 'bool']):\n frame[f.get_name()] = frame[f.get_name()].astype(float)\n\n return frame\n\n\ndef _can_agg(feature):\n assert isinstance(feature, AggregationPrimitive)\n base_features = feature.base_features\n if feature.where is not None:\n base_features = [bf.get_name() for bf in base_features\n if bf.get_name() != feature.where.get_name()]\n\n if feature.uses_calc_time:\n return False\n\n return len(base_features) == 1 and not feature.expanding\n\n\ndef agg_wrapper(feats, time_last):\n def wrap(df):\n d = {}\n for f in feats:\n func = f.get_function()\n variable_ids = [bf.get_name() for bf in f.base_features]\n args = [df[v] for v in variable_ids]\n\n if f.uses_calc_time:\n d[f.get_name()] = [func(args, time=time_last)]\n else:\n d[f.get_name()] = [func(args)]\n\n return pd.DataFrame(d)\n return wrap\n\n\ndef set_default_column(frame, f):\n default = f.default_value\n if hasattr(default, '__iter__'):\n length = frame.shape[0]\n default = [f.default_value] * length\n frame[f.get_name()] = default\n" ]	[ [ "pandas.api.types.is_categorical_dtype", "pandas.merge", "pandas.concat", "pandas.api.types.CategoricalDtype", "pandas.DataFrame" ] ]
uniomni/PyRate	[ "f77ad6e7fd90f3c0eb255bd553d4666b5db40bcf" ]	[ "tests/test_refpixel.py" ]	[ "# This Python module is part of the PyRate software package.\n#\n# Copyright 2020 Geoscience Australia\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"\nThis Python module contains tests for the refpixel.py PyRate module.\n\"\"\"\nimport copy\nimport shutil\nfrom subprocess import check_call, run\nfrom pathlib import Path\nimport pytest\nfrom numpy import nan, mean, std, isnan\n\nimport pyrate.core.refpixel\nfrom pyrate.core import config as cf\nfrom pyrate.core.refpixel import ref_pixel, _step, RefPixelError\nfrom pyrate.core import shared, ifgconstants as ifc\n\nfrom pyrate import process\nfrom pyrate.configuration import Configuration\nfrom tests.common import TEST_CONF_ROIPAC\nfrom tests.common import small_data_setup, MockIfg, copy_small_ifg_file_list, \\\n copy_and_setup_small_data, manipulate_test_conf, assert_two_dirs_equal, PYTHON3P6\n\n\n# TODO: figure out how editing resource.setrlimit fixes the error\n# to fix the open to many files error\n# https://stackoverflow.com/questions/18280612/ioerror-errno-24-too-many-open-files\n\n# default testing values\nREFNX = 5\nREFNY = 7\nMIN_FRAC = 0.7\nCHIPSIZE = 3\nPARALLEL = False\n\n\nclass TestReferencePixelInputTests:\n '''\n Verifies error checking capabilities of the reference pixel function\n '''\n\n @classmethod\n def setup_method(cls):\n cls.ifgs = small_data_setup()\n cls.params = cf.get_config_params(TEST_CONF_ROIPAC)\n cls.params[cf.REFNX] = REFNX\n cls.params[cf.REFNY] = REFNY\n cls.params[cf.REF_CHIP_SIZE] = CHIPSIZE\n cls.params[cf.REF_MIN_FRAC] = MIN_FRAC\n cls.params[cf.PARALLEL] = PARALLEL\n\n def test_missing_chipsize(self):\n self.params[cf.REF_CHIP_SIZE] = None\n with pytest.raises(cf.ConfigException):\n ref_pixel(self.ifgs, self.params)\n\n def test_chipsize_valid(self):\n for illegal in [0, -1, -15, 1, 2, self.ifgs[0].ncols+1, 4, 6, 10, 20]:\n self.params[cf.REF_CHIP_SIZE] = illegal\n with pytest.raises(RefPixelError):\n ref_pixel(self.ifgs, self.params)\n\n def test_minimum_fraction_missing(self):\n self.params[cf.REF_MIN_FRAC] = None\n with pytest.raises(cf.ConfigException):\n ref_pixel(self.ifgs, self.params)\n\n def test_minimum_fraction_threshold(self):\n for illegal in [-0.1, 1.1, 1.000001, -0.0000001]:\n self.params[cf.REF_MIN_FRAC] = illegal\n with pytest.raises(RefPixelError):\n ref_pixel(self.ifgs, self.params)\n\n def test_search_windows(self):\n # 45 is max # cells a width 3 sliding window can iterate over\n for illegal in [-5, -1, 0, 46, 50, 100]:\n self.params[cf.REFNX] = illegal\n with pytest.raises(RefPixelError):\n ref_pixel(self.ifgs, self.params)\n\n # 40 is max # cells a width 3 sliding window can iterate over\n for illegal in [-5, -1, 0, 71, 85, 100]:\n self.params[cf.REFNY] = illegal\n with pytest.raises(RefPixelError):\n ref_pixel(self.ifgs, self.params)\n\n def test_missing_search_windows(self):\n self.params[cf.REFNX] = None\n with pytest.raises(cf.ConfigException):\n ref_pixel(self.ifgs, self.params)\n\n self.params[cf.REFNX] = REFNX\n self.params[cf.REFNY] = None\n\n with pytest.raises(cf.ConfigException):\n ref_pixel(self.ifgs, self.params)\n\n\nclass TestReferencePixelTests:\n \"\"\"\n Tests reference pixel search\n \"\"\"\n\n @classmethod\n def setup_method(cls):\n cls.params = cf.get_config_params(TEST_CONF_ROIPAC)\n cls.params[cf.OUT_DIR], cls.ifgs = copy_and_setup_small_data()\n cls.params[cf.REFNX] = REFNX\n cls.params[cf.REFNY] = REFNY\n cls.params[cf.REF_CHIP_SIZE] = CHIPSIZE\n cls.params[cf.REF_MIN_FRAC] = MIN_FRAC\n cls.params[cf.PARALLEL] = PARALLEL\n\n def test_all_below_threshold_exception(self):\n # test failure when no valid stacks in dataset\n\n # rig mock data to be below threshold\n mock_ifgs = [MockIfg(i, 6, 7) for i in self.ifgs]\n for m in mock_ifgs:\n m.phase_data[:1] = nan\n m.phase_data[1:5] = 0.1\n m.phase_data[5:] = nan\n\n self.params[cf.REFNX] = 2\n self.params[cf.REFNY] = 2\n self.params[cf.REF_CHIP_SIZE] = CHIPSIZE\n self.params[cf.REF_MIN_FRAC] = MIN_FRAC\n self.params[cf.PARALLEL] = PARALLEL\n with pytest.raises(ValueError):\n ref_pixel(mock_ifgs, self.params)\n\n def test_refnxy_step_1(self):\n # test step of 1 for refnx\|y gets the reference pixel for axis centre\n mock_ifgs = [MockIfg(i, 47, 72) for i in self.ifgs]\n for m in mock_ifgs:\n m.phase_data[:1] = 0.2\n m.phase_data[1:5] = 0.1\n m.phase_data[5:] = 0.3\n exp_refpx = (1, 1)\n self.params[cf.REFNX] = 1\n self.params[cf.REFNY] = 1\n self.params[cf.REF_CHIP_SIZE] = CHIPSIZE\n self.params[cf.REF_MIN_FRAC] = MIN_FRAC\n self.params[cf.PARALLEL] = PARALLEL\n res = ref_pixel(mock_ifgs, self.params)\n assert exp_refpx == res\n\n def test_large_window(self):\n # 5x5 view over a 5x5 ifg with 1 window/ref pix search\n chps = 5\n mockifgs = [MockIfg(i, chps, chps) for i in self.ifgs]\n self.params[cf.REFNX] = 1\n self.params[cf.REFNY] = 1\n self.params[cf.REF_CHIP_SIZE] = chps\n self.params[cf.REF_MIN_FRAC] = MIN_FRAC\n self.params[cf.PARALLEL] = PARALLEL\n res = ref_pixel(mockifgs, self.params)\n assert (2, 2) == res\n\n def test_step(self):\n # test different search windows to verify x/y step calculation\n\n # convenience testing function\n def assert_equal(actual, expected):\n for a, e in zip(actual, expected):\n assert a == e\n\n # start with simple corner only test\n width = 47\n radius = 2\n refnx = 2\n exp = [2, 25, 44]\n act = _step(width, refnx, radius)\n assert_equal(act, exp)\n\n # test with 3 windows\n refnx = 3\n exp = [2, 17, 32]\n act = _step(width, refnx, radius)\n assert_equal(act, exp)\n\n # test 4 search windows\n refnx = 4\n exp = [2, 13, 24, 35]\n act = _step(width, refnx, radius)\n assert_equal(act, exp)\n\n def test_ref_pixel(self):\n exp_refpx = (2, 25)\n self.params[cf.REFNX] = 2\n self.params[cf.REFNY] = 2\n self.params[cf.REF_CHIP_SIZE] = 5\n self.params[cf.REF_MIN_FRAC] = MIN_FRAC\n self.params[cf.PARALLEL] = PARALLEL\n res = ref_pixel(self.ifgs, self.params)\n assert res == exp_refpx\n\n # Invalidate first data stack, get new refpix coods & retest\n for i in self.ifgs:\n i.phase_data[:30, :50] = nan\n\n exp_refpx = (38, 2)\n res = ref_pixel(self.ifgs, self.params)\n assert res == exp_refpx\n\n\ndef _expected_ref_pixel(ifgs, cs):\n \"\"\"Helper function for finding reference pixel when refnx/y=2\"\"\"\n\n # calculate expected data\n data = [i.phase_data for i in ifgs] # len 17 list of arrays\n ul = [i[:cs, :cs] for i in data] # upper left corner stack\n ur = [i[:cs, -cs:] for i in data]\n ll = [i[-cs:, :cs] for i in data]\n lr = [i[-cs:, -cs:] for i in data]\n\n ulm = mean([std(i[~isnan(i)]) for i in ul]) # mean std of all the layers\n urm = mean([std(i[~isnan(i)]) for i in ur])\n llm = mean([std(i[~isnan(i)]) for i in ll])\n lrm = mean([std(i[~isnan(i)]) for i in lr])\n assert isnan([ulm, urm, llm, lrm]).any() is False\n\n # coords of the smallest mean is the result\n mn = [ulm, urm, llm, lrm]\n\n\nclass TestLegacyEqualityTest:\n\n @classmethod\n def setup_method(cls):\n cls.params = cf.get_config_params(TEST_CONF_ROIPAC)\n cls.params[cf.PARALLEL] = 0\n cls.params[cf.OUT_DIR], cls.ifg_paths = copy_small_ifg_file_list()\n conf_file = Path(cls.params[cf.OUT_DIR], 'conf_file.conf')\n cf.write_config_file(params=cls.params, output_conf_file=conf_file)\n cls.params = Configuration(conf_file).__dict__\n cls.params_alt_ref_frac = copy.copy(cls.params)\n cls.params_alt_ref_frac[cf.REF_MIN_FRAC] = 0.5\n cls.params_all_2s = copy.copy(cls.params)\n cls.params_all_2s[cf.REFNX] = 2\n cls.params_all_2s[cf.REFNY] = 2\n cls.params_chipsize_15 = copy.copy(cls.params_all_2s)\n cls.params_chipsize_15[cf.REF_CHIP_SIZE] = 15\n cls.params_all_1s = copy.copy(cls.params)\n cls.params_all_1s[cf.REFNX] = 1\n cls.params_all_1s[cf.REFNY] = 1\n cls.params_all_1s[cf.REF_MIN_FRAC] = 0.7\n\n for p, q in zip(cls.params[cf.INTERFEROGRAM_FILES], cls.ifg_paths): # hack\n p.sampled_path = q\n p.tmp_sampled_path = q\n\n @classmethod\n def teardown_method(cls):\n shutil.rmtree(cls.params[cf.OUT_DIR])\n\n def test_small_test_data_ref_pixel_lat_lon_provided(self):\n self.params[cf.REFX], self.params[cf.REFY] = 150.941666654, -34.218333314\n refx, refy = pyrate.core.refpixel.ref_pixel_calc_wrapper(self.params)\n assert refx == 38\n assert refy == 58\n assert 0.8 == pytest.approx(self.params[cf.REF_MIN_FRAC])\n\n def test_small_test_data_ref_pixel(self):\n refx, refy = pyrate.core.refpixel.ref_pixel_calc_wrapper(self.params)\n assert refx == 38\n assert refy == 58\n assert 0.8 == pytest.approx(self.params[cf.REF_MIN_FRAC])\n\n def test_small_test_data_ref_chipsize_15(self):\n\n refx, refy = pyrate.core.refpixel.ref_pixel_calc_wrapper(self.params_chipsize_15)\n assert refx == 7\n assert refy == 7\n assert 0.5 == pytest.approx(self.params_alt_ref_frac[cf.REF_MIN_FRAC])\n\n def test_metadata(self):\n refx, refy = pyrate.core.refpixel.ref_pixel_calc_wrapper(self.params_chipsize_15)\n for i in self.ifg_paths:\n ifg = shared.Ifg(i)\n ifg.open(readonly=True)\n md = ifg.meta_data\n for k, v in zip([ifc.PYRATE_REFPIX_X, ifc.PYRATE_REFPIX_Y, ifc.PYRATE_REFPIX_LAT,\n ifc.PYRATE_REFPIX_LON, ifc.PYRATE_MEAN_REF_AREA, ifc.PYRATE_STDDEV_REF_AREA],\n [str(refx), str(refy), 0, 0, 0, 0]):\n assert k in md # metadata present\n # assert values\n ifg.close()\n\n def test_small_test_data_ref_all_1(self):\n refx, refy = pyrate.core.refpixel.ref_pixel_calc_wrapper(self.params_all_1s)\n assert 0.7 == pytest.approx(self.params_all_1s[cf.REF_MIN_FRAC])\n assert 1 == self.params_all_1s[cf.REFNX]\n assert 1 == self.params_all_1s[cf.REFNY]\n assert refx == 2\n assert refy == 2\n\n\nclass TestLegacyEqualityTestMultiprocessParallel:\n\n @classmethod\n def setup_method(cls):\n cls.params = cf.get_config_params(TEST_CONF_ROIPAC)\n cls.params[cf.PARALLEL] = 1\n cls.params[cf.OUT_DIR], cls.ifg_paths = copy_small_ifg_file_list()\n conf_file = Path(cls.params[cf.OUT_DIR], 'conf_file.conf')\n cf.write_config_file(params=cls.params, output_conf_file=conf_file)\n cls.params = Configuration(conf_file).__dict__\n cls.params_alt_ref_frac = copy.copy(cls.params)\n cls.params_alt_ref_frac[cf.REF_MIN_FRAC] = 0.5\n cls.params_all_2s = copy.copy(cls.params)\n cls.params_all_2s[cf.REFNX] = 2\n cls.params_all_2s[cf.REFNY] = 2\n cls.params_chipsize_15 = copy.copy(cls.params_all_2s)\n cls.params_chipsize_15[cf.REF_CHIP_SIZE] = 15\n cls.params_all_1s = copy.copy(cls.params)\n cls.params_all_1s[cf.REFNX] = 1\n cls.params_all_1s[cf.REFNY] = 1\n cls.params_all_1s[cf.REF_MIN_FRAC] = 0.7\n\n for p, q in zip(cls.params[cf.INTERFEROGRAM_FILES], cls.ifg_paths): # hack\n p.sampled_path = q\n p.tmp_sampled_path = q\n\n @classmethod\n def teardown_method(cls):\n shutil.rmtree(cls.params[cf.OUT_DIR])\n\n def test_small_test_data_ref_pixel(self):\n refx, refy = pyrate.core.refpixel.ref_pixel_calc_wrapper(self.params)\n assert refx == 38\n assert refy == 58\n assert 0.8 == pytest.approx(self.params[cf.REF_MIN_FRAC])\n\n def test_more_small_test_data_ref_pixel(self):\n\n refx, refy = pyrate.core.refpixel.ref_pixel_calc_wrapper(self.params_alt_ref_frac)\n assert refx == 38\n assert refy == 58\n assert 0.5 == pytest.approx(self.params_alt_ref_frac[cf.REF_MIN_FRAC])\n\n def test_small_test_data_ref_pixel_all_2(self):\n\n refx, refy = pyrate.core.refpixel.ref_pixel_calc_wrapper(self.params_all_2s)\n assert refx == 25\n assert refy == 2\n assert 0.5 == pytest.approx(self.params_alt_ref_frac[cf.REF_MIN_FRAC])\n\n def test_small_test_data_ref_chipsize_15(self):\n\n refx, refy = pyrate.core.refpixel.ref_pixel_calc_wrapper(self.params_chipsize_15)\n assert refx == 7\n assert refy == 7\n assert 0.5 == pytest.approx(self.params_alt_ref_frac[cf.REF_MIN_FRAC])\n\n def test_small_test_data_ref_all_1(self):\n\n refx, refy = pyrate.core.refpixel.ref_pixel_calc_wrapper(self.params_all_1s)\n\n assert 0.7 == pytest.approx(self.params_all_1s[cf.REF_MIN_FRAC])\n assert 1 == self.params_all_1s[cf.REFNX]\n assert 1 == self.params_all_1s[cf.REFNY]\n assert refx == 2\n assert refy == 2\n\n\[email protected]\[email protected](PYTHON3P6, reason='Skipped in python3p6')\ndef test_error_msg_refpixel_out_out_bounds(tempdir, gamma_conf):\n \"check correct latitude/longitude refpixel error is raised when specified refpixel is out of bounds\"\n for x, (refx, refy) in zip(['longitude', 'latitude', 'longitude and latitude'],\n [(150., -34.218333314), (150.941666654, -34.), (150, -34)]):\n _, out = _get_mlooked_files(gamma_conf, Path(tempdir()), refx=refx, refy=refy)\n msg = \"Supplied {} value is outside the bounds of the interferogram data\"\n assert msg.format(x) in out.stderr\n\n\[email protected]\[email protected](PYTHON3P6, reason='Skipped in python3p6')\ndef test_gamma_ref_pixel_search_vs_lat_lon(tempdir, gamma_conf):\n params_1, _ = _get_mlooked_files(gamma_conf, Path(tempdir()), refx=-1, refy=-1)\n params_2, _ = _get_mlooked_files(gamma_conf, Path(tempdir()), refx=150.941666654, refy=-34.218333314)\n assert_two_dirs_equal(params_1[cf.OUT_DIR], params_2[cf.OUT_DIR], f\"*{params_1[cf.IFG_CROP_OPT]}cr.tif\", 18)\n\n\ndef _get_mlooked_files(gamma_conf, tdir, refx, refy):\n params = manipulate_test_conf(gamma_conf, tdir)\n params[cf.REFX] = refx\n params[cf.REFY] = refy\n output_conf_file = 'config.conf'\n output_conf = tdir.joinpath(output_conf_file)\n cf.write_config_file(params=params, output_conf_file=output_conf)\n check_call(f\"pyrate conv2tif -f {output_conf}\", shell=True)\n check_call(f\"pyrate prepifg -f {output_conf}\", shell=True)\n stdout = run(f\"pyrate process -f {output_conf}\", shell=True, capture_output=True, text=True)\n print(\"============================================\", stdout)\n return params, stdout\n" ]	[ [ "numpy.isnan" ] ]
svebk/py-faster-rcnn	[ "1d0c40c42930f8e89634c057a0ed902aace395bd" ]	[ "lib/fast_rcnn/config.py" ]	[ "# --------------------------------------------------------\n# Fast R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick\n# --------------------------------------------------------\n\n\"\"\"Fast R-CNN config system.\n\nThis file specifies default config options for Fast R-CNN. You should not\nchange values in this file. Instead, you should write a config file (in yaml)\nand use cfg_from_file(yaml_file) to load it and override the default options.\n\nMost tools in $ROOT/tools take a --cfg option to specify an override file.\n - See tools/{train,test}_net.py for example code that uses cfg_from_file()\n - See experiments/cfgs/.yml for example YAML config override files\n\"\"\"\n\nimport os\nimport os.path as osp\nimport numpy as np\n# `pip install easydict` if you don't have it\nfrom easydict import EasyDict as edict\n\n__C = edict()\n# Consumers can get config by:\n# from fast_rcnn_config import cfg\ncfg = __C\n\n#\n# Training options\n#\n\n__C.TRAIN = edict()\n\n# Scales to use during training (can list multiple scales)\n# Each scale is the pixel size of an image's shortest side\n__C.TRAIN.SCALES = (600,)\n\n# Max pixel size of the longest side of a scaled input image\n__C.TRAIN.MAX_SIZE = 1000\n\n# Images to use per minibatch\n__C.TRAIN.IMS_PER_BATCH = 2\n\n# Minibatch size (number of regions of interest [ROIs])\n__C.TRAIN.BATCH_SIZE = 128\n\n# Fraction of minibatch that is labeled foreground (i.e. class > 0)\n__C.TRAIN.FG_FRACTION = 0.25\n\n# Overlap threshold for a ROI to be considered foreground (if >= FG_THRESH)\n__C.TRAIN.FG_THRESH = 0.5\n\n# Overlap threshold for a ROI to be considered background (class = 0 if\n# overlap in [LO, HI))\n__C.TRAIN.BG_THRESH_HI = 0.5\n__C.TRAIN.BG_THRESH_LO = 0.1\n\n# Use horizontally-flipped images during training?\n__C.TRAIN.USE_FLIPPED = True\n\n# Train bounding-box regressors\n__C.TRAIN.BBOX_REG = True\n\n# Overlap required between a ROI and ground-truth box in order for that ROI to\n# be used as a bounding-box regression training example\n__C.TRAIN.BBOX_THRESH = 0.5\n\n# Iterations between snapshots\n__C.TRAIN.SNAPSHOT_ITERS = 10000\n\n# solver.prototxt specifies the snapshot path prefix, this adds an optional\n# infix to yield the path: <prefix>[_<infix>]_iters_XYZ.caffemodel\n__C.TRAIN.SNAPSHOT_INFIX = ''\n\n# Use a prefetch thread in roi_data_layer.layer\n# So far I haven't found this useful; likely more engineering work is required\n__C.TRAIN.USE_PREFETCH = False\n\n# Normalize the targets (subtract empirical mean, divide by empirical stddev)\n__C.TRAIN.BBOX_NORMALIZE_TARGETS = True\n# Deprecated (inside weights)\n__C.TRAIN.BBOX_INSIDE_WEIGHTS = (1.0, 1.0, 1.0, 1.0)\n# Normalize the targets using \"precomputed\" (or made up) means and stdevs\n# (BBOX_NORMALIZE_TARGETS must also be True)\n__C.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED = False\n__C.TRAIN.BBOX_NORMALIZE_MEANS = (0.0, 0.0, 0.0, 0.0)\n__C.TRAIN.BBOX_NORMALIZE_STDS = (0.1, 0.1, 0.2, 0.2)\n\n# Train using these proposals\n__C.TRAIN.PROPOSAL_METHOD = 'selective_search'\n\n# Make minibatches from images that have similar aspect ratios (i.e. both\n# tall and thin or both short and wide) in order to avoid wasting computation\n# on zero-padding.\n__C.TRAIN.ASPECT_GROUPING = True\n\n# Use RPN to detect objects\n__C.TRAIN.HAS_RPN = False\n# IOU >= thresh: positive example\n__C.TRAIN.RPN_POSITIVE_OVERLAP = 0.7\n# IOU < thresh: negative example\n__C.TRAIN.RPN_NEGATIVE_OVERLAP = 0.3\n# If an anchor statisfied by positive and negative conditions set to negative\n__C.TRAIN.RPN_CLOBBER_POSITIVES = False\n# Max number of foreground examples\n__C.TRAIN.RPN_FG_FRACTION = 0.5\n# Total number of examples\n__C.TRAIN.RPN_BATCHSIZE = 256\n# NMS threshold used on RPN proposals\n__C.TRAIN.RPN_NMS_THRESH = 0.7\n# Number of top scoring boxes to keep before apply NMS to RPN proposals\n__C.TRAIN.RPN_PRE_NMS_TOP_N = 12000\n# Number of top scoring boxes to keep after applying NMS to RPN proposals\n__C.TRAIN.RPN_POST_NMS_TOP_N = 2000\n# Proposal height and width both need to be greater than RPN_MIN_SIZE (at orig image scale)\n__C.TRAIN.RPN_MIN_SIZE = 16\n# Deprecated (outside weights)\n__C.TRAIN.RPN_BBOX_INSIDE_WEIGHTS = (1.0, 1.0, 1.0, 1.0)\n# Give the positive RPN examples weight of p 1 / {num positives}\n# and give negatives a weight of (1 - p)\n# Set to -1.0 to use uniform example weighting\n__C.TRAIN.RPN_POSITIVE_WEIGHT = -1.0\n\n\n#\n# Testing options\n#\n\n__C.TEST = edict()\n\n# Scales to use during testing (can list multiple scales)\n# Each scale is the pixel size of an image's shortest side\n__C.TEST.SCALES = (600,)\n\n# Max pixel size of the longest side of a scaled input image\n__C.TEST.MAX_SIZE = 1000\n\n# Overlap threshold used for non-maximum suppression (suppress boxes with\n# IoU >= this threshold)\n__C.TEST.NMS = 0.3\n\n# Experimental: treat the (K+1) units in the cls_score layer as linear\n# predictors (trained, eg, with one-vs-rest SVMs).\n__C.TEST.SVM = False\n\n# Test using bounding-box regressors\n__C.TEST.BBOX_REG = True\n\n# Propose boxes\n__C.TEST.HAS_RPN = False\n\n# Test using these proposals\n__C.TEST.PROPOSAL_METHOD = 'selective_search'\n\n## NMS threshold used on RPN proposals\n__C.TEST.RPN_NMS_THRESH = 0.7\n## Number of top scoring boxes to keep before apply NMS to RPN proposals\n__C.TEST.RPN_PRE_NMS_TOP_N = 6000\n## Number of top scoring boxes to keep after applying NMS to RPN proposals\n__C.TEST.RPN_POST_NMS_TOP_N = 300\n# Proposal height and width both need to be greater than RPN_MIN_SIZE (at orig image scale)\n__C.TEST.RPN_MIN_SIZE = 16\n\n\n#\n# MISC\n#\n\n# The mapping from image coordinates to feature map coordinates might cause\n# some boxes that are distinct in image space to become identical in feature\n# coordinates. If DEDUP_BOXES > 0, then DEDUP_BOXES is used as the scale factor\n# for identifying duplicate boxes.\n# 1/16 is correct for {Alex,Caffe}Net, VGG_CNN_M_1024, and VGG16\n__C.DEDUP_BOXES = 1./16.\n\n# Pixel mean values (BGR order) as a (1, 1, 3) array\n# We use the same pixel mean for all networks even though it's not exactly what\n# they were trained with\n__C.PIXEL_MEANS = np.array([[[102.9801, 115.9465, 122.7717]]])\n\n# For reproducibility\n__C.RNG_SEED = 3\n\n# A small number that's used many times\n__C.EPS = 1e-14\n\n# Root directory of project\n__C.ROOT_DIR = osp.abspath(osp.join(osp.dirname(__file__), '..', '..'))\n\n# Data directory\n__C.DATA_DIR = osp.abspath(osp.join(__C.ROOT_DIR, 'data'))\n\n# Model directory\n__C.MODELS_DIR = osp.abspath(osp.join(__C.ROOT_DIR, 'models'))\n\n# Name (or path to) the matlab executable\n__C.MATLAB = 'matlab'\n\n# Place outputs under an experiments directory\n__C.EXP_DIR = 'default'\n\n# Use GPU implementation of non-maximum suppression\n__C.USE_GPU_NMS = True\n\n# Default GPU device id\n__C.GPU_ID = 0\n\n\ndef get_output_dir(imdb, net):\n \"\"\"Return the directory where experimental artifacts are placed.\n\n A canonical path is built using the name from an imdb and a network\n (if not None).\n \"\"\"\n path = osp.abspath(osp.join(__C.ROOT_DIR, 'output', __C.EXP_DIR, imdb.name))\n if net is None:\n return path\n else:\n return osp.join(path, net.name)\n\ndef _merge_a_into_b(a, b):\n \"\"\"Merge config dictionary a into config dictionary b, clobbering the\n options in b whenever they are also specified in a.\n \"\"\"\n if type(a) is not edict:\n return\n\n for k, v in a.iteritems():\n # a must specify keys that are in b\n if not b.has_key(k):\n raise KeyError('{} is not a valid config key'.format(k))\n\n # the types must match, too\n old_type = type(b[k])\n if old_type is not type(v):\n if isinstance(b[k], np.ndarray):\n v = np.array(v, dtype=b[k].dtype)\n else:\n raise ValueError(('Type mismatch ({} vs. {}) '\n 'for config key: {}').format(type(b[k]),\n type(v), k))\n\n # recursively merge dicts\n if type(v) is edict:\n try:\n _merge_a_into_b(a[k], b[k])\n except:\n print('Error under config key: {}'.format(k))\n raise\n else:\n b[k] = v\n\ndef cfg_from_file(filename):\n \"\"\"Load a config file and merge it into the default options.\"\"\"\n import yaml\n with open(filename, 'r') as f:\n yaml_cfg = edict(yaml.load(f))\n\n _merge_a_into_b(yaml_cfg, __C)\n\ndef cfg_from_list(cfg_list):\n \"\"\"Set config keys via list (e.g., from command line).\"\"\"\n from ast import literal_eval\n assert len(cfg_list) % 2 == 0\n for k, v in zip(cfg_list[0::2], cfg_list[1::2]):\n key_list = k.split('.')\n d = __C\n for subkey in key_list[:-1]:\n assert d.has_key(subkey)\n d = d[subkey]\n subkey = key_list[-1]\n assert d.has_key(subkey)\n try:\n value = literal_eval(v)\n except:\n # handle the case when v is a string literal\n value = v\n assert type(value) == type(d[subkey]), \\\n 'type {} does not match original type {}'.format(\n type(value), type(d[subkey]))\n d[subkey] = value\n" ]	[ [ "numpy.array" ] ]
KentaroKutsukake/Integrating-multiple-materials-science-projects	[ "a6f09583718fc00431a3ce67d5fc6f026646f91c" ]	[ "codes/MIGraph/Encoders/CompoundEncoder.py" ]	[ "\n\"\"\"\nCompound encoder\nthis class returns vector information of a target smiles\n\"\"\"\n\nimport numpy as np\nfrom Config import Config\n\nCF=Config()\ncategoryEmbed=CF.categoryEmbed\n\n\n#compound encoder class\nclass CompEncoder:\n def __init__(self,CompDat,num):\n \"\"\"\n CompDat: CompDatabase class\n num: =CF.ID_COMPOUNDS (=3)\n \"\"\"\n self.CompDat=CompDat \n self.num=num\n \n #get embetting vector\n def getEVector(self,string):\n \"\"\"\n input: SMILES\n return :embedding vector\n \"\"\"\n num=self.num\n res=self.CompDat.getCompDesc(string)\n num=categoryEmbed(np.array([num])).array\n \n return np.concatenate([num,res],1).reshape(-1)\n " ]	[ [ "numpy.concatenate", "numpy.array" ] ]
broestls/pycuda-bw-test	[ "0ac9a377363bb99bc1b9e5dd42bbdd0bd6d697c3" ]	[ "bwt.py" ]	[ "import numpy as np\n\nimport pycuda.driver as cuda\nfrom pycuda.compiler import SourceModule\nfrom pycuda.tools import make_default_context, clear_context_caches\n\nimport glob\nimport sys\nimport os\nfrom datetime import datetime\nimport ctypes\nimport atexit\nimport argparse\nimport subprocess\nimport psutil\nimport itertools\n\nfrom signal import signal, SIGINT\nfrom sys import exit\nfrom multiprocessing import Process, Value, set_start_method, Pool, cpu_count, current_process\nfrom codetiming import Timer\nfrom utils import calc_bws, calc_gbs\n\nglobal cuda_devices\n\nparser = argparse.ArgumentParser(description=\"A program for simulating load on GPU memory and system bus\")\ngroup = parser.add_mutually_exclusive_group(required=True)\ngroup.add_argument('--single', type=int, help=\"Run with a N constant size array\")\ngroup.add_argument('--batch', action='store_true')\ngroup.add_argument('--hwinfo', type=int, help=\"Gets info for CUDA device with ID\")\nparser.add_argument('-d', '--num_devices', type=int, help=\"Number of CUDA devices to use\")\nparser.add_argument('-i', '--iterations', type=int, default=1, help=\"number of iterations to run\")\nparser.add_argument('-w', '--workers', type=int, default=4, help=\"number of workers to spawn\")\nparser.add_argument('-e', '--elements', type=int, default=4, help=\"number of numpy arrays to work on\")\nparser.add_argument('--debug', action='store_true')\nparser.add_argument('-n', '--name', type=str, help='name to use for the run')\nargs = parser.parse_args()\n\ndef get_hw_info(device_id):\n device = cuda.Device(device_id)\n return \"device_id: {}, bus_id: {}, name: {}, cuda_version: {}\".format(device_id, device.pci_bus_id(), device.name(), cuda.get_version())\n\ndef handler(signal_received, frame):\n print('Shutting down...')\n exit(0)\n\ndef np_to_hmem(src, dest):\n source = src.ctypes.data_as(ctypes.POINTER(ctypes.c_float))\n destination = dest.ctypes.data_as(ctypes.POINTER(ctypes.c_float))\n size = src.size * ctypes.sizeof(ctypes.c_float)\n ctypes.memmove(source,destination,size)\n\ndef load_single_array(mb_size):\n return np.random.randn(int(mb_size * (10*6)/4)).astype(np.float32)\n\ndef transfer_data(size):\n t1 = Timer(name=\"total_memcpy_time\", logger=None)\n t1.start()\n cuda.init()\n device = cuda.Device(0)\n context = device.make_context()\n dev_id = context.get_device().pci_bus_id()\n np_array = np.random.randn(int(size (10*6)/4)).astype(np.float32)\n np_return = np.empty_like(np_array)\n mem_gpu = cuda.mem_alloc(np_array.nbytes)\n mem_host = cuda.register_host_memory(np_array)\n np_to_hmem(np_array,mem_host)\n t2 = Timer(name=\"hmem_to_dmem\", logger=None)\n t2.start()\n cuda.memcpy_htod(mem_gpu, mem_host)\n t2.stop()\n t3 = Timer(name=\"dmem_to_hmem\", logger=None)\n t3.start()\n return_data = np.empty_like(np_array)\n cuda.memcpy_dtoh(mem_host, mem_gpu)\n t3.stop()\n mem_host.base.unregister()\n mem_gpu.free()\n context.pop()\n context = None\n clear_context_caches()\n t1.stop()\n if(args.debug):\n print(\"{},{},{},{},{},{},{},{}\".format('htod-'+args.name+'-debug',args.single,format(t2.last, '.4f'),calc_gbs(size,t2.last),psutil.Process().cpu_num(),psutil.Process().pid,dev_id,current_process().name))\n print(\"{},{},{},{},{},{},{},{}\".format('dtoh-'+args.name+'-debug',args.single,format(t3.last, '.4f'),calc_gbs(size,t3.last),psutil.Process().cpu_num(),psutil.Process().pid,dev_id,current_process().name))\n return {'total_time':t1.last, 'htod': calc_gbs(size,t2.last), 'htod_time':t2.last, 'dtoh': calc_gbs(size,t3.last), 'dtoh_time':t3.last}\n\ndef devices_to_workers():\n cuda.init()\n global cuda_devices\n available_devices = args.num_cuda_devices\n for i in range(args.workers):\n cuda_devices[i] = 0\n\nif __name__ == \"__main__\":\n signal(SIGINT, handler)\n set_start_method('fork')\n np_list = [args.single for x in range(args.elements)]\n pool = Pool(processes=args.workers)\n for i in range(args.iterations):\n total_size = args.single args.elements\n res = pool.map(transfer_data, np_list)\n hotd_bandwidth = sum([float(x['htod']) for x in res])/args.elements\n dtoh_bandwidth = sum([float(x['dtoh']) for x in res])/args.elements\n total_time = sum([float(x['total_time']) for x in res])\n htod_time = sum([float(x['htod_time']) for x in res])\n dtoh_time = sum([float(x['dtoh_time']) for x in res])\n print(\"{},{},{},{},{},{},{},{},{},{}\".format(args.name,args.single,format(total_time, '.4f'),format(hotd_bandwidth, '.4f'),format(htod_time, '.4f'),format(dtoh_bandwidth, '.4f'),format(dtoh_time, '.4f'),args.workers,'epoch-'+str(i),datetime.now().strftime(\"%H:%M:%S:%f\")))\n if args.hwinfo != None:\n print(get_hw_info(args.hwinfo))" ]	[ [ "numpy.empty_like" ] ]
marcoalsina/araucaria	[ "78039106ae27d3fdef9265503c33f33992199d8e" ]	[ "docs/build/html/xas/xas_ft-5.py" ]	[ "from numpy import arange, sin, pi\nfrom scipy.fftpack import fftfreq\nfrom araucaria.xas import ftwindow, xftf_kwin, xftr_kwin\nnfft = 2048 # number of points for FFT\nks = 0.05 # delta k (angstrom^-1)\nf1 = 0.5 # freq1 (angstrom)\nk = arange(0, 10, ks)\nwink = ftwindow(k, x_range=(0,10), dx1=0.5, win='sine')\nchi = 0.5sin(2pikf1)\nchir = xftf_kwin(wink*chi, nfft=nfft, kstep=ks)\nfreq = fftfreq(nfft, ks)[:nfft//2]\nchiq = xftr_kwin(chir, nfft=nfft, kstep=ks)[:len(k)]\nprint(chiq.dtype)\n# complex128\n\n# plotting reverse FFT signal\nimport matplotlib.pyplot as plt\nfrom araucaria.plot import fig_xas_template\nfig, ax = fig_xas_template(panels='re', fig_pars={'kweight':0})\nline = ax[0].plot(freq, abs(chir))\nxlim = ax[0].set_xlim(0,2)\nxlab = ax[0].set_xlabel('$R/\\pi$ [$\\AA$]')\nline = ax[1].plot(k, chiq)\ntext = ax[1].set_xlabel(r'$q(\\AA^{-1})$')\ntext = ax[1].set_ylabel(r'$\\chi(q)$')\nfig.tight_layout()\nplt.show(block=False)\n" ]	[ [ "numpy.arange", "matplotlib.pyplot.show", "scipy.fftpack.fftfreq", "numpy.sin" ] ]
KirillDZR/supreme	[ "c296722599363bd0cbcce6877bd9de9b066cb74b" ]	[ "supreme/lib/klt/setup.py" ]	[ "from supreme._build import CExtension\n\ndef configuration(parent_package='', top_path=None):\n from numpy.distutils.misc_util import Configuration, get_numpy_include_dirs\n\n config = Configuration('klt', parent_package, top_path)\n\n config.ext_modules.append(CExtension('libklt_',\n ['convolve.c', 'error.c', 'pnmio.c',\n 'pyramid.c', 'selectGoodFeatures.c',\n 'storeFeatures.c', 'trackFeatures.c',\n 'klt.c', 'klt_util.c',\n 'writeFeatures.c'],\n path=config.local_path))\n\n config.add_data_dir('tests')\n\n return config\n" ]	[ [ "numpy.distutils.misc_util.Configuration" ] ]
davidarps/NeuroX	[ "591cabce7a317d2a1ff2b07e6a3b277250815454" ]	[ "neurox/interpretation/utils.py" ]	[ "import math\nimport numpy as np\n\nfrom imblearn.under_sampling import RandomUnderSampler\n\ndef isnotebook():\n \"\"\"\n Utility function to detect if the code being run is within a jupyter\n notebook. Useful to change progress indicators for example.\n\n Returns\n -------\n isnotebook : bool\n True if the function is being called inside a notebook, False otherwise.\n \"\"\"\n try:\n shell = get_ipython().__class__.__name__\n if shell == \"ZMQInteractiveShell\":\n return True # Jupyter notebook or qtconsole\n elif shell == \"TerminalInteractiveShell\":\n return False # Terminal running IPython\n else:\n return False # Other type (?)\n except NameError:\n return False # Probably standard Python interpreter\n\ndef get_progress_bar():\n \"\"\"\n Utility function to get a progress bar depending on the environment the code\n is running in. A normal text-based progress bar is returned in normal\n shells, and a notebook widget-based progress bar is returned in jupyter\n notebooks.\n\n Returns\n -------\n progressbar : function\n The appropriate progressbar from the tqdm library.\n\n \"\"\"\n if isnotebook():\n from tqdm import tqdm_notebook as progressbar\n else:\n from tqdm import tqdm as progressbar\n\n return progressbar\n\ndef batch_generator(X, y, batch_size=32):\n \"\"\"\n Generator function to generate batches of data for training/evaluation.\n\n This function takes two tensors representing the activations and labels\n respectively, and yields batches of parallel data. The last batch may\n contain fewer than ``batch_size`` elements.\n\n Parameters\n ----------\n X : numpy.ndarray\n Numpy Matrix of size [``NUM_TOKENS`` x ``NUM_NEURONS``]. Usually the\n output of ``interpretation.utils.create_tensors``\n y : numpy.ndarray\n Numpy Vector of size [``NUM_TOKENS``] with class labels for each input\n token. For classification, 0-indexed class labels for each input token\n are expected. For regression, a real value per input token is expected.\n Usually the output of ``interpretation.utils.create_tensors``\n batch_size : int, optional\n Number of samples to return in each call. Defaults to 32.\n\n Yields\n ------\n X_batch : numpy.ndarray\n Numpy Matrix of size [``batch_size`` x ``NUM_NEURONS``]. The final batch\n may have fewer elements than the requested ``batch_size``\n y_batch : numpy.ndarray\n Numpy Vector of size [``batch_size``]. The final batch may have fewer\n elements than the requested ``batch_size``\n \"\"\"\n start_idx = 0\n while start_idx < X.shape[0]:\n yield X[start_idx : start_idx + batch_size], y[\n start_idx : start_idx + batch_size\n ]\n start_idx = start_idx + batch_size\n\ndef tok2idx(tokens):\n \"\"\"\n Utility function to generate unique indices for a set of tokens.\n\n Parameters\n ----------\n tokens : list of lists\n List of sentences, where each sentence is a list of tokens. Usually\n returned from ``data.loader.load_data``\n\n Returns\n -------\n tok2idx_mapping : dict\n A dictionary with tokens as keys and a unique index for each token as\n values\n \"\"\"\n uniq_tokens = set().union(tokens)\n return {p: idx for idx, p in enumerate(uniq_tokens)}\n\n\ndef idx2tok(srcidx):\n \"\"\"\n Utility function to an inverse mapping from a ``tok2idx`` mapping.\n\n Parameters\n ----------\n tok2idx_mapping : dict\n Token to index mapping, usually the output for\n ``interpretation.utils.tok2idx``.\n\n Returns\n -------\n idx2tok : dict\n A dictionary with unique indices as keys and their associated tokens as\n values\n \"\"\"\n return {v: k for k, v in srcidx.items()}\n\n\ndef count_target_words(tokens):\n \"\"\"\n Utility function to count the total number of tokens in a dataset.\n\n Parameters\n ----------\n tokens : list of lists\n List of sentences, where each sentence is a list of tokens. Usually\n returned from ``data.loader.load_data``\n\n Returns\n -------\n count : int\n Total number of tokens in the given ``tokens`` structure\n \"\"\"\n return sum([len(t) for t in tokens[\"target\"]])\n\n\ndef create_tensors(\n tokens, activations, task_specific_tag, mappings=None, task_type=\"classification\", binarized_tag = None, balance_data = False, dtype=None\n):\n \"\"\"\n Method to pre-process loaded datasets into tensors that can be used to train\n probes and perform analyis on. The input tokens are represented as list of\n sentences, where each sentence is a list of tokens. Each token also has\n an associated label. All tokens from all sentences are flattened into one\n dimension in the returned tensors. The returned tensors will thus have\n ``total_num_tokens`` rows.\n\n Parameters\n ----------\n tokens : list of lists\n List of sentences, where each sentence is a list of tokens. Usually\n returned from ``data.loader.load_data``\n activations : list of numpy.ndarray\n List of sentence representations, where each sentence representation\n is a numpy matrix of shape\n ``[num tokens in sentence x concatenated representation size]``. Usually\n retured from ``data.loader.load_activations``\n task_specific_tag : str\n Label to assign tokens with unseen labels. This is particularly useful\n if some labels are never seen during train, but are present in the dev\n or test set. This is usually set to the majority class in the task.\n mappings : list of dicts\n List of four python dicts: ``label2idx``, ``idx2label``, ``src2idx`` and\n ``idx2src`` for classification tasks. List of two dicts ``src2idx`` and\n ``idx2src`` for regression tasks. Each dict represents either the\n mapping from class labels to indices and source tokens to indices or\n vice versa. Usually returned from a previous call to ``create_tensors``.\n task_type : str\n Either \"classification\" or \"regression\", indicate the kind of task that\n is being probed.\n binarized_tag : str, optional\n Tag/Label to create binary data. All other labels in the dataset are changed\n to OTHER. Defaults to None in which case the data labels are processed as-is.\n balance_data : bool, optional\n Whether the incoming data should be balanced. Data is balanced using \n utils.balance_binary_class_data for binary data and utils.balance_multi_class_data\n for multi-class data using undersampling. Defaults to False.\n dtype : str, optional\n None if the dtype of the activation tensor should be the same dtype as in the activations input\n e.g. 'float16' or 'float32' to enforce half-precision or full-precision floats\n\n\n Returns\n -------\n X : numpy.ndarray\n Numpy Matrix of size [``NUM_TOKENS`` x ``NUM_NEURONS``]\n y : numpy.ndarray\n Numpy vector of size [``NUM_TOKENS``]\n mappings : list of dicts\n List of four python dicts: ``label2idx``, ``idx2label``, ``src2idx`` and\n ``idx2src`` for classification tasks. List of two dicts ``src2idx`` and\n ``idx2src`` for regression tasks. Each dict represents either the\n mapping from class labels to indices and source tokens to indices or\n vice versa.\n\n Notes\n -----\n - ``mappings`` should be created exactly once, and should be reused for subsequent calls\n - For example, ``mappings`` can be created on train data, and the passed during the call for dev and test data.\n\n \"\"\"\n assert (\n task_type == \"classification\" or task_type == \"regression\"\n ), \"Invalid model type\"\n num_tokens = count_target_words(tokens)\n print(\"Number of tokens: \", num_tokens)\n\n num_neurons = activations[0].shape[1]\n\n source_tokens = tokens[\"source\"]\n target_tokens = tokens[\"target\"]\n\n ####### creating pos and source to index and reverse\n if mappings is not None:\n if task_type == \"classification\":\n label2idx, idx2label, src2idx, idx2src = mappings\n else:\n src2idx, idx2src = mappings\n else:\n if task_type == \"classification\":\n if binarized_tag: \n label2idx = {binarized_tag: 1, \"OTHER\": 0}\n idx2label = {1: binarized_tag, 0: \"OTHER\"}\n else:\n label2idx = tok2idx(target_tokens)\n idx2label = idx2tok(label2idx)\n\n src2idx = tok2idx(source_tokens)\n idx2src = idx2tok(src2idx)\n\n print(\"length of source dictionary: \", len(src2idx))\n if task_type == \"classification\":\n print(\"length of target dictionary: \", len(label2idx))\n\n if dtype==None:\n dtype=activations[0].dtype\n X = np.zeros((num_tokens, num_neurons), dtype=dtype)\n if task_type==\"classification\":\n y = np.zeros((num_tokens,), dtype=np.int)\n else:\n y = np.zeros((num_tokens,), dtype=np.float32)\n\n example_set = set()\n\n idx = 0\n for instance_idx, instance in enumerate(target_tokens):\n for token_idx, _ in enumerate(instance):\n if idx < num_tokens:\n X[idx] = activations[instance_idx][token_idx, :]\n\n example_set.add(source_tokens[instance_idx][token_idx])\n if task_type == \"classification\":\n current_target_token = target_tokens[instance_idx][token_idx]\n if binarized_tag and current_target_token != binarized_tag:\n current_target_token = \"OTHER\"\n if (\n mappings is not None\n and current_target_token not in label2idx\n ):\n y[idx] = label2idx[task_specific_tag]\n else:\n y[idx] = label2idx[current_target_token]\n elif task_type == \"regression\":\n y[idx] = float(target_tokens[instance_idx][token_idx])\n\n idx += 1\n\n print(idx)\n print(\"Total instances: %d\" % (num_tokens))\n print(list(example_set)[:20])\n\n print (\"Number of samples: \", X.shape[0])\n\n if balance_data:\n print (\"Balancing data ... \")\n if binarized_tag:\n X, y = balance_binary_class_data(X, y)\n else:\n X, y = balance_multi_class_data(X, y)\n print (\"Number of samples after balancing: \", X.shape[0])\n\n labels, freqs = np.unique(y, return_counts=True)\n\n print (\"Stats: Labels with their frequencies in the final set\")\n for idx, label in enumerate(labels):\n print (idx2label[label], freqs[idx])\n\n if task_type == \"classification\":\n return X, y, (label2idx, idx2label, src2idx, idx2src)\n return X, y, (src2idx, idx2src)\n\n\n################################## Statictics ##################################\ndef print_overall_stats(all_results):\n \"\"\"\n Method to pretty print overall results.\n\n .. warning::\n This method was primarily written to process results from internal\n scripts and pipelines.\n\n Parameters\n ----------\n all_results : dict\n Dictionary containing the probe, overall scores, scores from selected\n neurons, neuron ordering and neuron selections at various percentages\n\n \"\"\"\n probe = all_results[\"probe\"]\n weights = list(probe.parameters())[0].data.cpu()\n num_neurons = weights.numpy().shape[1]\n print(\n \"Overall accuracy: %0.02f%%\"\n % (100 all_results[\"original_accs\"][\"__OVERALL__\"])\n )\n\n print(\"\")\n print(\"Global results\")\n print(\"10% Neurons\")\n print(\n \"\\tKeep Top accuracy: %0.02f%%\"\n % (100 * all_results[\"global_results\"][\"10%\"][\"keep_top_accs\"][\"__OVERALL__\"])\n )\n print(\n \"\\tKeep Random accuracy: %0.02f%%\"\n % (\n 100\n * all_results[\"global_results\"][\"10%\"][\"keep_random_accs\"][\"__OVERALL__\"]\n )\n )\n print(\n \"\\tKeep Bottom accuracy: %0.02f%%\"\n % (\n 100\n * all_results[\"global_results\"][\"10%\"][\"keep_bottom_accs\"][\"__OVERALL__\"]\n )\n )\n print(\"15% Neurons\")\n print(\n \"\\tKeep Top accuracy: %0.02f%%\"\n % (100 * all_results[\"global_results\"][\"15%\"][\"keep_top_accs\"][\"__OVERALL__\"])\n )\n print(\n \"\\tKeep Random accuracy: %0.02f%%\"\n % (\n 100\n * all_results[\"global_results\"][\"15%\"][\"keep_random_accs\"][\"__OVERALL__\"]\n )\n )\n print(\n \"\\tKeep Bottom accuracy: %0.02f%%\"\n % (\n 100\n * all_results[\"global_results\"][\"15%\"][\"keep_bottom_accs\"][\"__OVERALL__\"]\n )\n )\n print(\"20% Neurons\")\n print(\n \"\\tKeep Top accuracy: %0.02f%%\"\n % (100 * all_results[\"global_results\"][\"20%\"][\"keep_top_accs\"][\"__OVERALL__\"])\n )\n print(\n \"\\tKeep Random accuracy: %0.02f%%\"\n % (\n 100\n * all_results[\"global_results\"][\"20%\"][\"keep_random_accs\"][\"__OVERALL__\"]\n )\n )\n print(\n \"\\tKeep Bottom accuracy: %0.02f%%\"\n % (\n 100\n * all_results[\"global_results\"][\"20%\"][\"keep_bottom_accs\"][\"__OVERALL__\"]\n )\n )\n print(\"\")\n print(\"Full order of neurons:\")\n print(all_results[\"global_results\"][\"ordering\"])\n\n print(\"--------------------\")\n print(\"\")\n print(\"Local results\")\n for idx, percentage in enumerate(all_results[\"local_results\"][\"percentages\"]):\n print(\"Weight Mass percentage: %d%%\" % (percentage * 100))\n _, top_neurons, top_neurons_per_tag = all_results[\"local_results\"][\n \"local_top_neurons\"\n ][idx]\n print(\n \"Percentage of all neurons: %0.0f%%\"\n % (100 * len(top_neurons) / num_neurons)\n )\n print(\"Top Neurons:\", sorted(top_neurons))\n print(\"\")\n print(\"Top neurons per tag:\")\n for tag in top_neurons_per_tag:\n print(\"\\t\" + tag + \":\", sorted(top_neurons_per_tag[tag]))\n print(\"\")\n\n\ndef print_machine_stats(all_results):\n \"\"\"\n Method to print overall results in tsv format.\n\n .. warning::\n This method was primarily written to process results from internal\n scripts and pipelines.\n\n Parameters\n ----------\n all_results : dict\n Dictionary containing the probe, overall scores, scores from selected\n neurons, neuron ordering and neuron selections at various percentages\n\n \"\"\"\n\n probe = all_results[\"probe\"]\n weights = list(probe.parameters())[0].data.cpu()\n num_neurons = weights.numpy().shape[1]\n print(\"Filtering out:\")\n print(\n \"%0.2f\\t%0.2f\\t%0.2f\\t%0.2f\\t%0.2f\\t%0.2f\\t%0.2f\\t%0.2f\\t%0.2f\\t%0.2f\\t%s\"\n % (\n 100 * all_results[\"original_accs\"][\"__OVERALL__\"],\n 100 * all_results[\"global_results\"][\"10%\"][\"keep_top_accs\"][\"__OVERALL__\"],\n 100\n * all_results[\"global_results\"][\"10%\"][\"keep_random_accs\"][\"__OVERALL__\"],\n 100\n * all_results[\"global_results\"][\"10%\"][\"keep_bottom_accs\"][\"__OVERALL__\"],\n 100 * all_results[\"global_results\"][\"15%\"][\"keep_top_accs\"][\"__OVERALL__\"],\n 100\n * all_results[\"global_results\"][\"15%\"][\"keep_random_accs\"][\"__OVERALL__\"],\n 100\n * all_results[\"global_results\"][\"15%\"][\"keep_bottom_accs\"][\"__OVERALL__\"],\n 100 * all_results[\"global_results\"][\"20%\"][\"keep_top_accs\"][\"__OVERALL__\"],\n 100\n * all_results[\"global_results\"][\"20%\"][\"keep_random_accs\"][\"__OVERALL__\"],\n 100\n * all_results[\"global_results\"][\"20%\"][\"keep_bottom_accs\"][\"__OVERALL__\"],\n str(all_results[\"global_results\"][\"ordering\"][:300]),\n )\n )\n print(\"\\nZero out:\")\n print(\n \"%0.2f\\t%0.2f\\t%0.2f\\t%0.2f\\t%0.2f\\t%0.2f\\t%0.2f\\t%0.2f\\t%0.2f\\t%0.2f\"\n % (\n 100 * all_results[\"original_accs\"][\"__OVERALL__\"],\n 100\n * all_results[\"global_results\"][\"10%\"][\"zero_out_top_accs\"][\"__OVERALL__\"],\n 100\n * all_results[\"global_results\"][\"10%\"][\"zero_out_random_accs\"][\n \"__OVERALL__\"\n ],\n 100\n * all_results[\"global_results\"][\"10%\"][\"zero_out_bottom_accs\"][\n \"__OVERALL__\"\n ],\n 100\n * all_results[\"global_results\"][\"15%\"][\"zero_out_top_accs\"][\"__OVERALL__\"],\n 100\n * all_results[\"global_results\"][\"15%\"][\"zero_out_random_accs\"][\n \"__OVERALL__\"\n ],\n 100\n * all_results[\"global_results\"][\"15%\"][\"zero_out_bottom_accs\"][\n \"__OVERALL__\"\n ],\n 100\n * all_results[\"global_results\"][\"20%\"][\"zero_out_top_accs\"][\"__OVERALL__\"],\n 100\n * all_results[\"global_results\"][\"20%\"][\"zero_out_random_accs\"][\n \"__OVERALL__\"\n ],\n 100\n * all_results[\"global_results\"][\"20%\"][\"zero_out_bottom_accs\"][\n \"__OVERALL__\"\n ],\n )\n )\n\n for idx, percentage in enumerate(all_results[\"local_results\"][\"percentages\"]):\n print(\"\\nLocal %d%%:\" % (percentage * 100))\n top_neurons = all_results[\"local_results\"][\"local_top_neurons\"][idx][1]\n top_neurons_per_tag = all_results[\"local_results\"][\"local_top_neurons\"][idx][2]\n top_neurons_per_tag_list = {k: list(v) for k, v in top_neurons_per_tag.items()}\n print(\n \"%0.2f%%\\t%s\\t%s\"\n % (\n 100 * len(top_neurons) / num_neurons,\n str(sorted(top_neurons)),\n str(top_neurons_per_tag_list),\n )\n )\n\n\n################################ Data Balancing ################################\ndef balance_binary_class_data(X, y):\n \"\"\"\n Method to balance binary class data.\n\n .. note::\n The majority class is under-sampled randomly to match the minority class\n in it's size.\n\n Parameters\n ----------\n X : numpy.ndarray\n Numpy Matrix of size [``NUM_TOKENS`` x ``NUM_NEURONS``]. Usually\n returned from ``interpretation.utils.create_tensors``\n y : numpy.ndarray\n Numpy vector of size [``NUM_TOKENS``]. Usually returned from\n ``interpretation.utils.create_tensors``\n\n Returns\n -------\n X_balanced : numpy.ndarray\n Numpy matrix of size [``NUM_BALANCED_TOKENS`` x ``NUM_NEURONS``]\n y_balanced : numpy.ndarray\n Numpy vector of size [``NUM_BALANCED_TOKENS``]\n\n \"\"\"\n rus = RandomUnderSampler()\n X_res, y_res = rus.fit_resample(X, y)\n\n return X_res, y_res\n\n\ndef balance_multi_class_data(X, y, num_required_instances=None):\n \"\"\"\n Method to balance multi class data.\n\n .. note::\n All classes are under-sampled randomly to match the minority class in\n their size. If ``num_required_instances`` is provided, all classes are\n sampled proportionally so that the total number of selected examples is\n approximately ``num_required_instances`` (because of rounding proportions).\n\n Parameters\n ----------\n X : numpy.ndarray\n Numpy Matrix of size [``NUM_TOKENS`` x ``NUM_NEURONS``]. Usually\n returned from ``interpretation.utils.create_tensors``\n y : numpy.ndarray\n Numpy vector of size [``NUM_TOKENS``]. Usually returned from\n ``interpretation.utils.create_tensors``\n num_required_instances : int, optional\n Total number of required instances. All classes are sampled\n proportionally.\n\n Returns\n -------\n X_balanced : numpy.ndarray\n Numpy matrix of size [``NUM_BALANCED_TOKENS`` x ``NUM_NEURONS``]\n y_balanced : numpy.ndarray\n Numpy vector of size [``NUM_BALANCED_TOKENS``]\n\n \"\"\"\n if num_required_instances:\n total = y.shape[0]\n unique, counts = np.unique(y, return_counts=True)\n class_counts = dict(zip(unique, counts))\n num_instances_per_class = {\n key: math.ceil(count / total * num_required_instances)\n for key, count in class_counts.items()\n }\n print(num_instances_per_class)\n rus = RandomUnderSampler(sampling_strategy=num_instances_per_class)\n else:\n rus = RandomUnderSampler()\n\n X_res, y_res = rus.fit_resample(X, y)\n\n return X_res, y_res\n\ndef load_probe(probe_path):\n \"\"\"\n Loads a probe and its associated mappings from probe_path\n\n .. warning::\n This method is currently not implemented.\n\n Parameters\n ----------\n probe_path : str\n Path to a pkl object saved by interpretation.utils.save_probe\n\n Returns\n -------\n probe : interpretation.linear_probe.LinearProbe\n Trained probe model\n mappings : list of dicts\n List of four python dicts: ``label2idx``, ``idx2label``, ``src2idx`` and\n ``idx2src`` for classification tasks. List of two dicts ``src2idx`` and\n ``idx2src`` for regression tasks. Each dict represents either the\n mapping from class labels to indices and source tokens to indices or\n vice versa.\n\n \"\"\"\n pass\n\ndef save_probe(probe_path, probe, mappings):\n \"\"\"\n Saves a model and its associated mappings as a pkl object at probe_path\n\n .. warning::\n This method is currently not implemented.\n\n Parameters\n ----------\n probe_path : str\n Path to save a pkl object\n probe : interpretation.linear_probe.LinearProbe\n Trained probe model\n mappings : list of dicts\n List of four python dicts: ``label2idx``, ``idx2label``, ``src2idx`` and\n ``idx2src`` for classification tasks. List of two dicts ``src2idx`` and\n ``idx2src`` for regression tasks. Each dict represents either the\n mapping from class labels to indices and source tokens to indices or\n vice versa.\n\n \"\"\"\n pass" ]	[ [ "numpy.zeros", "numpy.unique" ] ]
DennisSoemers/rliable	[ "9f4c97d59196b70518f1ee3ba6d4f03a302c3241" ]	[ "rliable/library.py" ]	[ "# coding=utf-8\n# Copyright 2021 The Rliable Authors.\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"Main library functions for interval estimates and performance profiles.\"\"\"\n\nfrom typing import Callable, Dict, List, Optional, Tuple, Union, Mapping\nfrom absl import logging\nimport arch.bootstrap as arch_bs\nimport numpy as np\nfrom numpy import random\n\nFloat = Union[float, np.float32, np.float64]\n\n\n####################### Stratified Bootstrap #######################\nclass StratifiedBootstrap(arch_bs.IIDBootstrap):\n \"\"\"Bootstrap using stratified resampling.\n\n Supports numpy arrays. Data returned has the same type as the input data.\n Data entered using keyword arguments is directly accessibly as an attribute.\n\n To ensure a reproducible bootstrap, you must set the `random_state`\n attribute after the bootstrap has been created. See the example below.\n Note that `random_state` is a reserved keyword and any variable\n passed using this keyword must be an instance of `RandomState`.\n\n Examples\n --------\n Data can be accessed in a number of ways. Positional data is retained in\n the same order as it was entered when the bootstrap was initialized.\n Keyword data is available both as an attribute or using a dictionary syntax\n on kw_data.\n\n >>> from rliable.library import StratifiedBootstrap\n >>> from numpy.random import standard_normal\n >>> x = standard_normal((5, 50))\n >>> bs = StratifiedBootstrap(x)\n >>> for data in bs.bootstrap(100):\n ... bs_x = data[0][0]\n >>> bs.conf_int(np.mean, method='percentile', reps=50000) # 95% CIs for mean\n\n Set the random_state if reproducibility is required.\n\n >>> from numpy.random import RandomState\n >>> rs = RandomState(1234)\n >>> bs = StratifiedBootstrap(x, random_state=rs)\n\n See also: `arch.bootstrap.IIDBootstrap`\n\n Attributes:\n data: tuple, Two-element tuple with the pos_data in the first position and\n kw_data in the second (pos_data, kw_data). Derived from `IIDBootstrap`.\n pos_data: tuple, Tuple containing the positional arguments (in the order\n entered). Derived from `IIDBootstrap`.\n kw_data: dict, Dictionary containing the keyword arguments. Derived from\n `IIDBootstrap`.\n \"\"\"\n\n _name = 'Stratified Bootstrap'\n\n def __init__(\n self,\n args: np.ndarray,\n random_state: Optional[random.RandomState] = None,\n task_bootstrap: bool = False,\n kwargs: np.ndarray,\n ) -> None:\n \"\"\"Initializes StratifiedBootstrap.\n\n Args:\n args: Positional arguments to bootstrap. Typically used for the\n performance on a suite of tasks with multiple runs/episodes. The inputs\n are assumed to be of the shape `(num_runs, num_tasks, ..)`.\n random_state: If specified, ensures reproducibility in uncertainty\n estimates.\n task_bootstrap: Whether to perform bootstrapping (a) over runs or (b) over\n both runs and tasks. Defaults to False which corresponds to (a). (a)\n captures the statistical uncertainty in the aggregate performance if the\n experiment is repeated using a different set of runs (e.g., changing\n seeds) on the same set of tasks. (b) captures the sensitivity of the\n aggregate performance to a given task and provides the performance\n estimate if we had used a larger unknown population of tasks.\n *kwargs: Keyword arguments, passed directly to `IIDBootstrap`.\n \"\"\"\n\n super().__init__(args, random_state=random_state, *kwargs)\n self._args_shape = args[0].shape\n self._num_tasks = self._args_shape[1]\n self._parameters = [self._num_tasks, task_bootstrap]\n self._task_bootstrap = task_bootstrap\n self._strata_indices = self._get_strata_indices()\n\n def _get_strata_indices(self) -> List[np.ndarray]:\n \"\"\"Samples partial indices for bootstrap resamples.\n\n Returns:\n A list of arrays of size N x 1 x 1 x .., 1 x M x 1 x ..,\n 1 x 1 x L x .. and so on, where the `args_shape` is `N x M x L x ..`.\n \"\"\"\n ogrid_indices = tuple(slice(x) for x in (0, self._args_shape[1:]))\n strata_indices = np.ogrid[ogrid_indices]\n return strata_indices[1:]\n\n def update_indices(self,) -> Tuple[np.ndarray, ...]:\n \"\"\"Selects the indices to sample from the bootstrap distribution.\"\"\"\n # `self._num_items` corresponds to the number of runs\n indices = np.random.choice(self._num_items, self._args_shape, replace=True)\n if self._task_bootstrap:\n task_indices = np.random.choice(\n self._num_tasks, self._strata_indices[0].shape, replace=True)\n return (indices, task_indices, self._strata_indices[1:])\n return (indices, self._strata_indices)\n\n\nclass StratifiedIndependentBootstrap(arch_bs.IndependentSamplesBootstrap):\n \"\"\"Stratified Bootstrap where each input is independently resampled.\n\n This bootstrap is useful for computing CIs for metrics which take multiple\n score arrays, possibly with different number of runs, as input, such as\n average probability of improvement. See also: `StratifiedBootstrap` and\n `arch_bs.IndependentSamplesBootstrap`.\n\n Attributes:\n data: tuple, Two-element tuple with the pos_data in the first position and\n kw_data in the second (pos_data, kw_data). Derived from\n `IndependentSamplesBootstrap`.\n pos_data: tuple, Tuple containing the positional arguments (in the order\n entered). Derived from `IndependentSamplesBootstrap`.\n kw_data: dict, Dictionary containing the keyword arguments. Derived from\n `IndependentSamplesBootstrap`.\n \"\"\"\n\n def __init__(\n self,\n args: np.ndarray,\n random_state: Optional[random.RandomState] = None,\n kwargs: np.ndarray,\n ) -> None:\n \"\"\"Initializes StratifiedIndependentSamplesBootstrap.\n\n Args:\n args: Positional arguments to bootstrap. Typically used for the\n performance on a suite of tasks with multiple runs/episodes. The inputs\n are assumed to be of the shape `(num_runs, num_tasks, ..)`.\n random_state: If specified, ensures reproducibility in uncertainty\n estimates.\n *kwargs: Keyword arguments, passed directly to `IIDBootstrap`.\n \"\"\"\n\n super().__init__(args, random_state=random_state, *kwargs)\n self._args_shapes = [arg.shape for arg in args]\n self._kwargs_shapes = {key: val.shape for key, val in self._kwargs.items()}\n self._args_strata_indices = [\n self._get_strata_indices(arg_shape) for arg_shape in self._args_shapes\n ]\n self._kwargs_strata_indices = {\n key: self._get_strata_indices(kwarg_shape)\n for key, kwarg_shape in self._kwargs_shapes.items()\n }\n\n def _get_strata_indices(\n self, array_shape: Tuple[int, ...]) -> List[np.ndarray]:\n \"\"\"Samples partial indices for bootstrap resamples.\n\n Args:\n array_shape: Shape of array for which strata indices are created.\n\n Returns:\n A list of arrays of size N x 1 x 1 x .., 1 x M x 1 x ..,\n 1 x 1 x L x .. and so on, where the `array_shape` is `N x M x L x ..`.\n \"\"\"\n ogrid_indices = tuple(slice(x) for x in (0, array_shape[1:]))\n strata_indices = np.ogrid[ogrid_indices]\n return strata_indices[1:]\n\n def _get_indices(self, num_runs: int, array_shape: Tuple[int, ...],\n strata_indices: List[np.ndarray]) -> Tuple[np.ndarray, ...]:\n \"\"\"Helper function for updating bootstrap indices.\"\"\"\n indices = np.random.choice(num_runs, array_shape, replace=True)\n return (indices, strata_indices)\n\n def update_indices(\n self,\n ) -> Tuple[List[Tuple[np.ndarray, ...]], Dict[str, Tuple[np.ndarray, ...]]]:\n \"\"\"Update independent sampling indices for the next bootstrap iteration.\"\"\"\n\n pos_indices = [\n self._get_indices(self._num_arg_items[i], self._args_shapes[i],\n self._args_strata_indices[i])\n for i in range(self._num_args)\n ]\n kw_indices = {}\n for key in self._kwargs:\n kw_indices[key] = self._get_indices(self._num_kw_items[key],\n self._kwargs_shapes[key],\n self._kwargs_strata_indices[key])\n return pos_indices, kw_indices\n\n\n####################### Interval Estimates #######################\ndef get_interval_estimates(\n score_dict: Union[Mapping[str, np.ndarray], Mapping[str, List[np.ndarray]]],\n func: Callable[..., np.ndarray],\n method: str = 'percentile',\n task_bootstrap: bool = False,\n reps: int = 50000,\n confidence_interval_size: Float = 0.95,\n random_state: Optional[random.RandomState] = None,\n) -> Tuple[Dict[str, np.ndarray], Dict[str, np.ndarray]]:\n \"\"\"Computes interval estimates via stratified bootstrap confidence intervals.\n\n Args:\n score_dict: A dictionary of scores for each method where scores are arranged\n as a matrix of the shape (`num_runs` x `num_tasks` x ..). For example, the\n scores could be 2D matrix containing final scores of the algorithm or a 3D\n matrix containing evaluation scores at multiple points during training.\n func: Function that computes the aggregate performance, which outputs a 1D\n numpy array. See Notes for requirements. For example, if computing\n estimates for interquartile mean across all runs, pass the function as\n `lambda x: np.array([metrics.aggregate_IQM])`.\n method: One of `basic`, `percentile`, `bc` (identical to `debiased`,\n `bias-corrected’), or ‘bca`.\n task_bootstrap: Whether to perform bootstrapping over tasks in addition to\n runs. Defaults to False. See `StratifiedBoostrap` for more details.\n reps: Number of bootstrap replications.\n confidence_interval_size: Coverage of confidence interval. Defaults to 95%.\n random_state: If specified, ensures reproducibility in uncertainty\n estimates.\n\n Returns:\n point_estimates: A dictionary of point estimates obtained by applying `func`\n on score data corresponding to each key in `data_dict`.\n interval_estimates: Confidence intervals~(CIs) for point estimates. Default\n is to return 95% CIs. Returns a np array of size (2 x ..) where the first\n row contains the lower bounds while the second row contains the upper\n bound of the 95% CIs.\n Notes:\n When there are no extra keyword arguments, the function is called\n\n .. code:: python\n\n func(args, *kwargs)\n\n where args and kwargs are the bootstrap version of the data provided\n when setting up the bootstrap. When extra keyword arguments are used,\n these are appended to kwargs before calling func.\n\n The bootstraps are:\n\n 'basic' - Basic confidence using the estimated parameter and\n difference between the estimated parameter and the bootstrap\n parameters.\n * 'percentile' - Direct use of bootstrap percentiles.\n * 'bc' - Bias corrected using estimate bootstrap bias correction.\n * 'bca' - Bias corrected and accelerated, adding acceleration parameter\n to 'bc' method.\n \"\"\"\n interval_estimates, point_estimates = {}, {}\n for key, scores in score_dict.items():\n logging.info('Calculating estimates for %s ...', key)\n if isinstance(scores, np.ndarray):\n stratified_bs = StratifiedBootstrap(\n scores, task_bootstrap=task_bootstrap, random_state=random_state)\n point_estimates[key] = func(scores)\n else:\n # Pass arrays as separate arguments, `task_bootstrap` is not supported\n stratified_bs = StratifiedIndependentBootstrap(\n scores,\n random_state=random_state)\n point_estimates[key] = func(scores)\n interval_estimates[key] = stratified_bs.conf_int(\n func, reps=reps, size=confidence_interval_size, method=method)\n return point_estimates, interval_estimates\n\n\n####################### Performance Profiles #######################\ndef run_score_deviation(scores: np.ndarray, tau: Float) -> Float:\n \"\"\"Evaluates how many `scores` are above `tau` averaged across all runs.\"\"\"\n return np.mean(scores > tau)\n\n\ndef mean_score_deviation(scores: np.ndarray, tau: Float) -> Float:\n \"\"\"Evaluates how many average task `scores` are above `tau`.\"\"\"\n return np.mean(np.mean(scores, axis=0) > tau)\n\n\nscore_distributions = np.vectorize(run_score_deviation, excluded=[0])\naverage_score_distributions = np.vectorize(mean_score_deviation, excluded=[0])\n\n\ndef create_performance_profile(\n score_dict: Mapping[str, np.ndarray],\n tau_list: Union[List[Float], np.ndarray],\n use_score_distribution: bool = True,\n custom_profile_func: Optional[Callable[..., np.ndarray]] = None,\n method: str = 'percentile',\n task_bootstrap: bool = False,\n reps: int = 2000,\n confidence_interval_size: Float = 0.95\n) -> Tuple[Dict[str, np.ndarray], Dict[str, np.ndarray]]:\n \"\"\"Function for calculating performance profiles.\n\n Args:\n score_dict: A dictionary of scores for each method where scores are arranged\n as a matrix of the shape (`num_runs` x `num_tasks` x ..).\n tau_list: List or 1D numpy array of threshold values on which the profile is\n evaluated.\n use_score_distribution: Whether to report score distributions or average\n score distributions. Defaults to score distributions for smaller\n uncertainty in reported results with unbiased profiles.\n custom_profile_func: Custom performance profile function. Can be used to\n compute performance profiles other than score distributions.\n method: Bootstrap method for `StratifiedBootstrap`, defaults to percentile.\n task_bootstrap: Whether to perform bootstrapping over tasks in addition to\n runs. Defaults to False. See `StratifiedBoostrap` for more details.\n reps: Number of bootstrap replications.\n confidence_interval_size: Coverage of confidence interval. Defaults to 95%.\n\n Returns:\n profiles: A dictionary of performance profiles for each key in `score_dict`.\n Each profile is a 1D np array of same size as `tau_list`.\n profile_cis: The 95% confidence intervals of profiles evaluated at\n all threshdolds in `tau_list`.\n \"\"\"\n\n if custom_profile_func is None:\n\n def profile_function(scores):\n if use_score_distribution:\n # Performance profile for scores across all tasks and runs\n return score_distributions(scores, tau_list)\n # Performance profile for task scores averaged across runs\n return average_score_distributions(scores, tau_list)\n else:\n profile_function = lambda scores: custom_profile_func(scores, tau_list)\n\n profiles, profile_cis = get_interval_estimates(\n score_dict,\n func=profile_function,\n task_bootstrap=task_bootstrap,\n method=method,\n reps=reps,\n confidence_interval_size=confidence_interval_size)\n return profiles, profile_cis\n" ]	[ [ "numpy.vectorize", "numpy.mean", "numpy.random.choice" ] ]
NREL/WaterTAP3	[ "74b83dbd189784ccfddac4bc5d27002190473619" ]	[ "watertap3/watertap3/wt_units/ion_exchange.py" ]	[ "import pandas as pd\nfrom pyomo.environ import \nfrom pyomo.environ import units as pyunits\nfrom pyomo.repn.plugins.baron_writer import NonNegativeReals\n\nfrom watertap3.utils import financials\nfrom watertap3.wt_units.wt_unit import WT3UnitProcess\n\n## REFERENCE: ADD REFERENCE HERE\n\nmodule_name = 'ion_exchange'\nbasis_year = 2016 # 2016 is costing year for EPA component costing data\ntpec_or_tic = 'TIC'\n\n\nclass UnitProcess(WT3UnitProcess):\n\n def fixed_cap(self, unit_params):\n '''\n Docstrings go here.\n \n :return:\n '''\n time = self.flowsheet().config.time\n\n self.total_ix_cap = Var(time,\n initialize=25,\n domain=NonNegativeReals,\n doc='Total ion exchange FCI [$MM]')\n\n self.cap_per_column = Var(time,\n initialize=1,\n domain=NonNegativeReals,\n doc='Capital per column [$MM]')\n\n self.column_total_cap = Var(time,\n initialize=1,\n domain=NonNegativeReals,\n doc='Total column capital [$MM]')\n\n self.resin_unit_cap = Var(time,\n initialize=4000,\n domain=NonNegativeReals,\n doc='Resin cap per m3 [$/m3]')\n\n self.resin_cap = Var(time,\n initialize=1E4,\n domain=NonNegativeReals,\n doc='Resin capital [$MM]')\n\n self.regen_pump_cap = Var(time,\n initialize=100,\n domain=NonNegativeReals,\n doc='Pump capital for regen cycle [$MM]')\n\n self.bw_pump_cap = Var(time,\n initialize=100,\n domain=NonNegativeReals,\n doc='Pump capital for backwash cycle [$MM]')\n\n self.rinse_pump_cap = Var(time,\n initialize=100,\n domain=NonNegativeReals,\n doc='Pump capital for rinse cycle [$MM]')\n\n self.boost_pump_cap = Var(time,\n initialize=100,\n domain=NonNegativeReals,\n doc='Pump capital for booster pump [#MM]')\n\n if self.pv_material == 'carbon_w_stainless_internals':\n self.cap_per_column_constr = Constraint(expr=self.cap_per_column[self.t] ==\n (16504 self.column_vol[self.t] ** 0.43) * 1E-6)\n if self.pv_material == 'carbon_w_plastic_internals':\n self.cap_per_column_constr = Constraint(expr=self.cap_per_column[self.t] ==\n (9120 * self.column_vol[self.t] ** 0.49) * 1E-6)\n if self.pv_material == 'fiberglass':\n self.cap_per_column_constr = Constraint(expr=self.cap_per_column[self.t] ==\n (5637 * self.column_vol[self.t] ** 0.9) * 1E-6)\n\n self.col_total_cap_constr = Constraint(expr=self.column_total_cap[self.t] == self.cap_per_column[self.t] * (self.num_columns[self.t] + 1))\n\n self.resin_unit_cap.fix(self.resin_dict[self.resin_type])\n\n self.resin_cap_constr = Constraint(expr=self.resin_cap[self.t] == ((self.resin_vol[self.t] + self.resin_per_column[self.t]) * self.resin_unit_cap[self.t]) * 1E-6) # include an additional resin vol per column to account for the extra column\n\n self.regen_pump_cap_constr = Constraint(expr=self.regen_pump_cap[self.t] == (-24.257 * self.regen_flow[self.t] ** 2 + 2803.7 * self.regen_flow[self.t] + 7495.7) \n (self.num_columns[self.t] + 1) 1E-6) # assumes centrifugal pump and 1 pump per column\n\n self.bw_pump_cap_constr = Constraint(expr=self.bw_pump_cap[self.t] == (-24.257 * self.bw_flow[self.t] ** 2 + 2803.7 * self.bw_flow[self.t] + 7495.7) \n (self.num_columns[self.t] + 1) 1E-6) # assumes centrifugal pump and 1 pump per column\n\n self.rinse_pump_cap_constr = Constraint(expr=self.rinse_pump_cap[self.t] == (-24.257 * self.rinse_flow[self.t] ** 2 + 2803.7 * self.rinse_flow[self.t] + 7495.7) \n (self.num_columns[self.t] + 1) 1E-6) # assumes centrifugal pump and 1 pump per column\n\n self.flow_per_col_m3_min = pyunits.convert(self.flow_per_column[self.t], to_units=pyunits.m ** 3 / pyunits.min)\n\n self.boost_pump_cap_constr = Constraint(expr=self.boost_pump_cap[self.t] == (-24.257 * self.flow_per_col_m3_min ** 2 + 2803.7 * self.flow_per_col_m3_min + 7495.7) \n (self.num_columns[self.t] + 1) 1E-6) # assumes centrifugal pump and 1 pump per column\n\n self.total_ix_cap_constr = Constraint(expr=self.total_ix_cap[self.t] ==\n self.column_total_cap[self.t] + self.resin_cap[self.t] + self.regen_pump_cap[self.t] + self.bw_pump_cap[self.t] + self.rinse_pump_cap[self.t] + self.boost_pump_cap[self.t])\n return self.total_ix_cap[self.t] * self.tpec_tic\n\n def elect(self):\n\n '''\n Electricity intensity for ion exchange\n\n :return:\n '''\n time = self.flowsheet().config.time\n\n self.main_pump_ei = Var(time,\n initialize=4E-6,\n domain=NonNegativeReals,\n doc='Electricity intensity for main pump [kWh/m3]')\n\n self.regen_pump_ei = Var(time,\n initialize=4E-6,\n domain=NonNegativeReals,\n doc='Electricity intensity for regen pump [kWh/m3]')\n\n self.bw_pump_ei = Var(time,\n initialize=4E-6,\n domain=NonNegativeReals,\n doc='Electricity intensity for backwash pump [kWh/m3]')\n\n self.rinse_pump_ei = Var(time,\n initialize=4E-6,\n domain=NonNegativeReals,\n doc='Electricity intensity for rinse pump [kWh/m3]')\n\n self.total_pump_ei = Var(time,\n initialize=4E-5,\n domain=NonNegativeReals,\n doc='Total pumping electricity intensity [kWh/m3]')\n\n flow_out_m3_hr = pyunits.convert(self.flow_vol_out[self.t], to_units=pyunits.m 3 / pyunits.hr)\n flow_waste_m3_hr = pyunits.convert(self.flow_vol_waste[self.t], to_units=pyunits.m 3 / pyunits.hr)\n\n self.main_pump_ei_constr = Constraint(expr=self.main_pump_ei[self.t] == ((1000 * 9.81 * self.pressure_drop[self.t] * 0.703249) / (3.6E6 * 0.7)) / flow_out_m3_hr)\n\n self.regen_pump_ei_constr = Constraint(expr=self.regen_pump_ei[self.t] == ((1000 * 9.81) / (3.6E6 * 0.7)) / flow_waste_m3_hr)\n\n self.bw_pump_ei_constr = Constraint(expr=self.bw_pump_ei[self.t] == ((1000 * 9.81) / (3.6E6 * 0.7)) / flow_waste_m3_hr)\n\n self.rinse_pump_ei_constr = Constraint(expr=self.rinse_pump_ei[self.t] == ((1000 * 9.81) / (3.6E6 * 0.7)) / flow_waste_m3_hr)\n\n self.total_pump_ei_constr = Constraint(expr=self.total_pump_ei[self.t] == self.main_pump_ei[self.t] + self.regen_pump_ei[self.t] + self.bw_pump_ei[self.t] + self.rinse_pump_ei[self.t])\n\n return self.total_pump_ei[self.t] * self.tpec_tic\n\n def sba(self, unit_params):\n '''\n Function for Strong-Base Anion Exchange Model\n\n :param unit_params:\n :return:\n '''\n\n time = self.flowsheet().config.time\n\n ### REGEN VARIABLES\n\n self.regen_dose = Var(time,\n initialize=300,\n domain=NonNegativeReals,\n units=pyunits.kg / pyunits.m 3,\n bounds=(80, 500),\n doc='NaCl dose required for regeneration [kg/m3]')\n\n self.regen_rate = Var(time,\n initialize=4,\n domain=NonNegativeReals,\n bounds=(2, 5),\n doc='Regeneration rate [BV/hr]')\n\n self.regen_density = Var(time,\n initialize=1000,\n domain=NonNegativeReals,\n units=pyunits.kg / pyunits.m 3,\n bounds=(990, 1200),\n doc='Density of NaCl regen solution [kg/m3]')\n\n self.regen_ww = Var(time,\n initialize=0.1,\n domain=NonNegativeReals,\n bounds=(0.015, 0.26),\n doc='Strength of NaCl solution w/w [kg NaCl/kg soln]')\n\n self.regen_conc = Var(time,\n initialize=110,\n domain=NonNegativeReals,\n units=pyunits.kg / pyunits.m 3,\n doc='Concentration of regen solution [kg/m3]')\n\n self.regen_vol = Var(time,\n initialize=2,\n domain=NonNegativeReals,\n doc='m3 of regen solution per m3 resin')\n\n self.regen_soln_per_column = Var(time,\n initialize=50,\n domain=NonNegativeReals,\n units=pyunits.m 3,\n doc='Regen solution used per column [m3/column]')\n\n self.regen_soln_per_column_annual = Var(time,\n initialize=1E3,\n domain=NonNegativeReals,\n units=pyunits.m 3 / pyunits.year,\n doc='Annual regen used per column [m3/year]')\n\n self.regen_soln_annual = Var(time,\n initialize=1E5,\n domain=NonNegativeReals,\n units=pyunits.m 3 / pyunits.year,\n doc='Total volume regen solution used [m3/year]')\n\n self.regen_time_per_column = Var(time,\n initialize=5,\n domain=NonNegativeReals,\n units=pyunits.min,\n doc='Regen time per column [min]')\n\n self.regen_flow = Var(time,\n initialize=10,\n domain=NonNegativeReals,\n units=pyunits.m 3 / pyunits.min,\n doc='Regeneration flow rate [m3/min]')\n\n self.num_regen_per_column_annual = Var(time,\n initialize=200,\n domain=NonNegativeReals,\n doc='Number of regen cycles per year')\n\n self.salt_per_regen_per_column = Var(time,\n initialize=5E3,\n domain=NonNegativeReals,\n doc='Number of regen cycles per year')\n\n self.salt_per_column_annual = Var(time,\n initialize=1E5,\n domain=NonNegativeReals,\n units=pyunits.kg / pyunits.year,\n doc='Mass of salt per column per year [kg/yr]')\n\n self.salt_total_annual = Var(time,\n initialize=1E6,\n domain=NonNegativeReals,\n units=pyunits.kg / pyunits.year,\n doc='Mass of salt per year [kg/yr]')\n\n self.salt_dose = Var(time,\n initialize=0.1,\n domain=NonNegativeReals,\n units=pyunits.kg / pyunits.m 3,\n doc='Salt dose for system [kg/m3]')\n\n self.total_regen_time = Var(time,\n initialize=30,\n units=pyunits.min,\n domain=NonNegativeReals,\n doc='Total regeneration cycle time [min]')\n\n self.regen_dose.fix(300)\n\n try:\n self.regen_ww.fix(unit_params['regen_ww'])\n except KeyError:\n self.regen_ww.fix(0.1)\n\n ### BACKWASH VARIABLES\n\n self.bw_rate = Var(time,\n initialize=6,\n domain=NonNegativeReals,\n units=pyunits.m / pyunits.hour,\n bounds=(4.5, 8),\n doc='Backwash rate [m/hr]')\n\n self.bw_time = Var(time,\n initialize=6,\n domain=NonNegativeReals,\n units=pyunits.minute,\n bounds=(4, 20),\n doc='Backwash time [min]')\n\n self.bw_flow = Var(time,\n initialize=5,\n domain=NonNegativeReals,\n units=pyunits.m 3 / pyunits.minute,\n doc='Backwash flow rate [m3/min]')\n\n self.bed_expansion = Var(time,\n initialize=0.5,\n domain=NonNegativeReals,\n units=pyunits.dimensionless,\n bounds=(0.4, 0.8),\n doc='Resin bed expansion during backwash [%]')\n\n self.bed_expansion_h = Var(time,\n # initialize=0.5,\n domain=NonNegativeReals,\n units=pyunits.m,\n bounds=(0.5, 3),\n doc='Resin bed expansion during backwash [m]')\n\n # self.bw_time.fix(6)\n self.bw_time.fix(12)\n\n ### RINSE VARIABLES\n\n self.rinse_bv = Var(time,\n initialize=5,\n domain=NonNegativeReals,\n bounds=(2, 10),\n doc='Number of bed volumes for rinse step [BV]')\n\n self.rinse_vol_per_column = Var(time,\n initialize=150,\n domain=NonNegativeReals,\n units=pyunits.m 3,\n doc='Rinse volume per column [m3/col]')\n\n self.rinse_vol_per_column_annual = Var(time,\n initialize=5E3,\n domain=NonNegativeReals,\n units=pyunits.m 3 / pyunits.year,\n doc='Rinse volume per column [m3/yr]')\n\n self.rinse_time_per_column = Var(time,\n initialize=4,\n domain=NonNegativeReals,\n units=pyunits.min,\n doc='Rinse time per column [min]')\n\n self.rinse_flow = Var(time,\n initialize=2,\n domain=NonNegativeReals,\n units=pyunits.m 3 / pyunits.min,\n doc='Rinse step flow rate [m3/min]')\n\n self.rinse_bv.fix(5)\n\n ### RESIN AND FLOW VARIABLES\n\n ix_df = self.ix_df = pd.read_csv('data/ix_sba.csv', index_col='constituent')\n self.cons = [c for c in self.config.property_package.component_list if c in ix_df.index]\n ix_df = self.ix_df = ix_df.loc[self.cons].copy()\n self.sep_factor_dict = ix_df.to_dict()['sep_factor']\n self.meq_conv_dict = ix_df.to_dict()['meq']\n\n try:\n self.target = unit_params['target']\n except:\n self.cons_df = self.source_df.loc[[c for c in self.cons if c != 'chloride']].copy()\n self.cons_df['meq_L'] = [(self.cons_df.loc[c].value * 1E3) / self.meq_conv_dict[c] for c in self.cons if c != 'chloride']\n self.target = self.cons_df.meq_L.idxmax()\n\n for k, v in self.sep_factor_dict.items():\n if v > self.sep_factor_dict[self.target]:\n self.sep_factor_dict[k] = 0.99 * self.sep_factor_dict[self.target]\n\n self.sep_factor = Param(self.cons,\n initialize=self.sep_factor_dict)\n\n self.meq_conv = Param(self.cons,\n initialize=self.meq_conv_dict)\n\n self.target_removal = Var(time,\n initialize=1,\n domain=NonNegativeReals,\n bounds=(0.0001, 1),\n doc='Removal fraction for target compound')\n\n self.sfr = Var(time,\n initialize=30,\n domain=NonNegativeReals,\n bounds=(6, 50),\n doc='Service flow rate [BV/hr]')\n\n self.loading_rate = Var(time,\n initialize=20,\n domain=NonNegativeReals,\n bounds=(10, 40),\n units=pyunits.m / pyunits.hr,\n doc='Column loading rate (superficial velocity) [m/hr]')\n\n self.cycle_time = Var(time,\n initialize=100,\n domain=NonNegativeReals,\n units=pyunits.hr,\n doc='Service cycle time [hr]')\n\n self.ebct = Var(time,\n initialize=1.1,\n domain=NonNegativeReals,\n units=pyunits.min,\n doc='Empty Bed Contact Time [min]')\n\n self.mg_L = Var(time,\n self.cons,\n initialize=1,\n domain=NonNegativeReals,\n doc='Influent concentration in mg/L')\n\n self.meq_L = Var(time,\n self.cons,\n initialize=0.1,\n domain=NonNegativeReals,\n doc='Influent concentration in meq/L')\n\n self.mass_in = Var(time,\n self.cons,\n initialize=200,\n domain=NonNegativeReals,\n doc='Influent mass [eq]')\n\n self.mass_removed = Var(time,\n self.cons,\n initialize=10,\n domain=NonNegativeReals,\n doc='Mass removed [eq]')\n\n self.frac_removed = Var(time,\n self.cons,\n initialize=0.8,\n domain=NonNegativeReals,\n doc='Fraction removed [%]')\n\n self.denom_resin = Var(time,\n initialize=1,\n domain=NonNegativeReals)\n\n self.denom_aq = Var(time,\n initialize=1,\n domain=NonNegativeReals)\n\n self.resin_conc = Var(time,\n self.cons,\n initialize=0.1,\n domain=NonNegativeReals,\n doc='Resin phase concentration of each ion [eq/L resin]')\n\n self.max_vol_treated = Var(time,\n initialize=5E3,\n domain=NonNegativeReals,\n bounds=(100, 1E6),\n units=pyunits.L / pyunits.L,\n doc='Max volume of water treated before breakthrough [L water/L resin]')\n\n self.resin_capacity = Var(time,\n initialize=1.2,\n domain=NonNegativeReals,\n bounds=(0.9, 1.5),\n doc='Resin capacity [eq/L]')\n\n self.resin_vol = Var(time,\n # initialize=100,\n domain=NonNegativeReals,\n units=pyunits.m 3,\n doc='Resin volume needed [m3]')\n\n self.resin_area = Var(time,\n initialize=100,\n domain=NonNegativeReals,\n units=pyunits.m 2,\n doc='Resin cross-sectional area needed [m2]')\n\n self.resin_depth = Var(time,\n initialize=1.5,\n domain=NonNegativeReals,\n bounds=(0.75, 3),\n units=pyunits.m,\n doc='Resin bed depth [m]')\n\n self.resin_depth_to_column_diam_ratio = Var(time,\n initialize=1,\n domain=NonNegativeReals,\n bounds=(0.6, 1.6),\n units=pyunits.dimensionless,\n doc='Ratio of resin depth to column height')\n\n self.resin_per_column = Var(time,\n initialize=15,\n domain=NonNegativeReals,\n units=pyunits.m 3,\n doc='Resin per column [m3]')\n\n self.resin_loss_frac_annual = Var(time,\n initialize=0.045,\n domain=NonNegativeReals,\n bounds=(3.75, 5.25),\n doc='Fraction of resin replaced per year [%]')\n\n self.resin_loss_annual = Var(time,\n initialize=20,\n domain=NonNegativeReals,\n units=pyunits.m 3,\n doc='Resin replaced per year [m3]')\n\n #### COLUMN VARIABLES\n\n self.column_h = Var(time,\n initialize=2,\n domain=NonNegativeReals,\n units=pyunits.m,\n bounds=(1, 16),\n doc='Column height [m]')\n\n self.column_diam = Var(time,\n initialize=2,\n domain=NonNegativeReals,\n units=pyunits.m,\n bounds=(1, 4),\n doc='Column diameter [m]')\n\n self.column_area = Var(time,\n initialize=15,\n domain=NonNegativeReals,\n units=pyunits.m 2,\n doc='Column cross-sectional area [m2]')\n\n if self.pv_material == 'fiberglass':\n self.column_vol = Var(time,\n initialize=2,\n domain=NonNegativeReals,\n bounds=(0.5, 4),\n units=pyunits.m 3,\n doc='Column volume [m3]')\n\n else:\n self.column_vol = Var(time,\n initialize=35,\n domain=NonNegativeReals,\n bounds=(0.5, 25),\n units=pyunits.m 3,\n doc='Column volume [m3]')\n\n self.num_columns = Var(time,\n initialize=2,\n domain=NonNegativeReals,\n bounds=(1, 1E5),\n units=pyunits.dimensionless,\n doc='Number of columns in parallel')\n\n self.underdrain_h = Var(time,\n initialize=0.5,\n domain=NonNegativeReals,\n units=pyunits.m,\n doc='Underdrain height [m]')\n\n self.distributor_h = Var(time,\n initialize=1,\n domain=NonNegativeReals,\n units=pyunits.m,\n doc='Distributor height [m]')\n\n self.flow_per_column = Var(time,\n initialize=250,\n domain=NonNegativeReals,\n units=pyunits.m 3 / pyunits.hr,\n doc='Flow per column [m3/hr]')\n\n self.pressure_drop = Var(time,\n initialize=14,\n domain=NonNegativeReals,\n units=pyunits.psi,\n bounds=(0, 25),\n doc='Pressure drop across column [psi]')\n\n self.resin_capacity.fix(1.2)\n # self.resin_capacity.fix(0.9435)\n # self.sfr.fix(30)\n self.loading_rate.fix(20)\n self.underdrain_h.fix(0.5)\n self.distributor_h.fix(1)\n self.resin_loss_frac_annual.fix(0.045)\n # self.column_diam.fix(3)\n\n try:\n self.target_removal = unit_params['target_removal']\n except KeyError:\n self.target_removal.fix(1)\n\n flow_out_m3_hr = pyunits.convert(self.flow_vol_out[self.t], to_units=pyunits.m 3 / pyunits.hr)\n flow_out_m3_yr = pyunits.convert(self.flow_vol_out[self.t], to_units=pyunits.m 3 / pyunits.year)\n flow_out_L_hr = pyunits.convert(self.flow_vol_out[self.t], to_units=pyunits.L / pyunits.hr)\n\n ############################# CONSTRAINTS START\n #### RESIN AND PERFORMANCE CONSTRAINTS\n\n self.mg_L_constr = ConstraintList()\n self.meq_L_constr = ConstraintList()\n self.resin_conc_constr = ConstraintList()\n self.mass_in_constr = ConstraintList()\n self.mass_removed_constr = ConstraintList()\n self.frac_removed_constr = ConstraintList()\n\n for c in self.cons:\n self.mg_L_constr.add(self.mg_L[self.t, c] == (self.conc_mass_in[self.t, c] * 1E3))\n self.meq_L_constr.add(self.meq_L[self.t, c] == self.mg_L[self.t, c] / self.meq_conv[c])\n self.resin_conc_constr.add(self.resin_conc[self.t, c] == (self.resin_capacity[self.t] * self.sep_factor[c] * self.meq_L[self.t, c]) /\n self.denom_resin[self.t])\n self.mass_in_constr.add(self.mass_in[self.t, c] == self.meq_L[self.t, c] * flow_out_m3_hr * self.cycle_time[self.t] * 1E-3)\n self.mass_removed_constr.add(self.mass_removed[self.t, c] == (self.resin_conc[self.t, c] / self.max_vol_treated[self.t]) * flow_out_m3_hr * self.cycle_time[self.t])\n self.frac_removed_constr.add(self.frac_removed[self.t, c] == 0.99 * (self.mass_removed[self.t, c] / self.mass_in[self.t, c]))\n\n self.denom_resin_constr = Constraint(expr=self.denom_resin[self.t] == sum(self.meq_L[self.t, c] * self.sep_factor[c] for c in self.cons))\n self.denom_aq_constr = Constraint(expr=self.denom_aq[self.t] == sum(self.resin_conc[self.t, c] / self.sep_factor[c] for c in self.cons))\n\n self.max_vol_treated_constr = Constraint(expr=self.max_vol_treated[self.t] == (self.resin_conc[self.t, self.target] * 1E3) /\n (self.meq_L[self.t, self.target] * self.target_removal[self.t]))\n\n self.resin_vol_constr = Constraint(expr=self.resin_vol[self.t] == flow_out_m3_hr / self.sfr[self.t])\n resin_vol_L = pyunits.convert(self.resin_vol[self.t], to_units=pyunits.L)\n\n self.resin_depth_to_column_diam_ratio_constr = Constraint(expr=self.resin_depth_to_column_diam_ratio[self.t] == self.resin_depth[self.t] / self.column_diam[self.t])\n\n self.resin_loss_annual_constr = Constraint(expr=self.resin_loss_annual[self.t] == self.resin_vol[self.t] * self.resin_loss_frac_annual[self.t])\n\n self.cycle_time_constr = Constraint(expr=self.cycle_time[self.t] == (self.max_vol_treated[self.t] * resin_vol_L) / flow_out_L_hr)\n\n self.resin_area_constr = Constraint(expr=self.resin_area[self.t] == self.resin_vol[self.t] / self.resin_depth[self.t])\n\n self.column_area_constr = Constraint(expr=self.column_area[self.t] == 3.141592 * (self.column_diam[self.t] / 2) ** 2)\n\n self.num_columns_constr = Constraint(expr=self.num_columns[self.t] == self.resin_area[self.t] / self.column_area[self.t])\n\n self.flow_per_col_constr = Constraint(expr=self.flow_per_column[self.t] == flow_out_m3_hr / self.num_columns[self.t])\n\n self.resin_per_col_constr = Constraint(expr=self.resin_per_column[self.t] == self.resin_vol[self.t] / self.num_columns[self.t])\n\n self.loading_rate_constr1 = Constraint(expr=self.loading_rate[self.t] == self.flow_per_column[self.t] / self.column_area[self.t])\n self.loading_rate_constr2 = Constraint(expr=self.loading_rate[self.t] == self.sfr[self.t] * self.resin_depth[self.t])\n\n self.pressure_drop_constr = Constraint(expr=self.pressure_drop[self.t] == (8.28E-04 * self.loading_rate[self.t] ** 2 + 0.173 * self.loading_rate[self.t] + 0.609) * self.resin_depth[self.t]) # Curve for 20C temperatuer\n\n self.column_h_constr = Constraint(expr=self.column_h[self.t] == self.resin_depth[self.t] + self.bed_expansion_h[self.t] + self.distributor_h[self.t] + self.underdrain_h[self.t])\n\n self.column_vol_constr = Constraint(expr=self.column_vol[self.t] == 3.14159 * (self.column_diam[self.t] / 2) ** 2 * self.column_h[self.t])\n\n self.ebct_constr = Constraint(expr=self.ebct[self.t] == (self.resin_depth[self.t] / self.loading_rate[self.t]) * 60)\n\n #### REGEN CONSTRAINTS\n\n self.regen_density_constr = Constraint(expr=self.regen_density[self.t] == 994.34 + 761.65 * self.regen_ww[self.t]) # kg Nacl / m3 resin\n\n self.regen_conc_constr = Constraint(expr=self.regen_conc[self.t] == self.regen_ww[self.t] * self.regen_density[self.t])\n\n self.regen_vol_constr = Constraint(expr=self.regen_vol[self.t] == self.regen_dose[self.t] / self.regen_conc[self.t]) # m3 regen soln / m3 resin\n\n self.num_regen_per_column_annual_constr = Constraint(expr=self.num_regen_per_column_annual[self.t] == 8760 / self.cycle_time[self.t]) # numerator is hours per year\n\n self.salt_per_regen_per_column_constr = Constraint(expr=self.salt_per_regen_per_column[self.t] == self.resin_per_column[self.t] * self.regen_dose[self.t])\n\n self.salt_per_col_annual_constr = Constraint(expr=self.salt_per_column_annual[self.t] == self.num_regen_per_column_annual[self.t] * self.salt_per_regen_per_column[self.t]) # kg / year per column\n\n self.salt_total_annual_constr = Constraint(expr=self.salt_total_annual[self.t] == self.salt_per_column_annual[self.t] * self.num_columns[self.t]) # kg / year\n\n self.salt_dose_constr = Constraint(expr=self.salt_dose[self.t] == self.salt_total_annual[self.t] / flow_out_m3_yr)\n\n self.regen_soln_per_col_constr = Constraint(expr=self.regen_soln_per_column[self.t] == self.resin_per_column[self.t] * self.regen_vol[self.t])\n\n self.regen_soln_per_col_annual_constr = Constraint(expr=self.regen_soln_per_column_annual[self.t] == self.regen_soln_per_column[self.t] * self.num_regen_per_column_annual[self.t])\n\n self.regen_soln_annual_constr = Constraint(expr=self.regen_soln_annual[self.t] == self.regen_soln_per_column_annual[self.t] * self.num_columns[self.t])\n\n self.regen_time_per_col_constr = Constraint(expr=self.regen_time_per_column[self.t] == self.ebct[self.t] * self.regen_vol[self.t])\n\n self.total_regen_time_constr = Constraint(expr=self.total_regen_time[self.t] == self.regen_time_per_column[self.t] + self.rinse_time_per_column[self.t] + self.bw_time[self.t])\n\n self.regen_flow_constr = Constraint(expr=self.regen_flow[self.t] == self.column_vol[self.t] / self.regen_time_per_column[self.t])\n\n ##### BW CONSTRAINTS\n\n self.bed_exp_constr = Constraint(expr=self.bed_expansion[self.t] == -1.35E-3 * self.bw_rate[self.t] ** 2 + 1.02E-1 * self.bw_rate[self.t] - 1.23E-2)\n\n self.bed_exp_h_constr = Constraint(expr=self.bed_expansion_h[self.t] == self.resin_depth[self.t] * self.bed_expansion[self.t])\n\n self.bw_flow_constr = Constraint(expr=self.bw_flow[self.t] == self.column_vol[self.t] / self.bw_time[self.t])\n\n ##### RINSE CONSTRAINTS\n\n self.rinse_vol_per_column_constr = Constraint(expr=self.rinse_vol_per_column[self.t] == self.resin_per_column[self.t] * self.rinse_bv[self.t])\n\n self.rinse_vol_per_col_annual_constr = Constraint(expr=self.rinse_vol_per_column_annual[self.t] == self.rinse_vol_per_column[self.t] * self.num_regen_per_column_annual[self.t])\n\n self.rinse_time_per_col_constr = Constraint(expr=self.rinse_time_per_column[self.t] == self.ebct[self.t] * self.rinse_bv[self.t])\n\n self.rinse_flow_constr = Constraint(expr=self.rinse_flow[self.t] == self.column_vol[self.t] / self.rinse_time_per_column[self.t])\n\n ##### WATER RECOVERY, CHEM DICT, AND CONSTITUENT REMOVAL\n\n self.wr_constr = Constraint(expr=self.water_recovery[self.t] == 1 - (self.total_regen_time[self.t] / ((self.cycle_time[self.t] * 60) + self.total_regen_time[self.t])))\n\n self.chem_dict = {\n 'Sodium_Chloride': self.salt_dose[self.t]\n }\n\n self.del_component(self.component_removal_equation)\n\n self.ix_component_removal = ConstraintList()\n for c in self.config.property_package.component_list:\n if c in self.cons:\n self.ix_component_removal.add(self.frac_removed[self.t, c] * self.flow_vol_in[self.t] * self.conc_mass_in[self.t, c] ==\n self.flow_vol_waste[self.t] * self.conc_mass_waste[self.t, c])\n else:\n self.ix_component_removal.add(self.removal_fraction[self.t, c] * self.flow_vol_in[self.t] * self.conc_mass_in[self.t, c] ==\n self.flow_vol_waste[self.t] * self.conc_mass_waste[self.t, c])\n\n def sac(self, unit_params):\n '''\n Function for Strong-Acid Cation Exchange Model\n :param unit_params:\n :return:\n '''\n\n ### REGEN VARIABLES\n\n time = self.flowsheet().config.time\n\n ### REGEN VARIABLES\n\n self.regen_dose = Var(time,\n initialize=300,\n domain=NonNegativeReals,\n units=pyunits.kg / pyunits.m 3,\n bounds=(80, 500),\\\n doc='NaCl dose required for regeneration [kg/m3]')\n\n self.regen_rate = Var(time,\n initialize=4,\n domain=NonNegativeReals,\n bounds=(2, 5),\n doc='Regeneration rate [BV/hr]')\n\n self.regen_density = Var(time,\n initialize=1000,\n domain=NonNegativeReals,\n units=pyunits.kg / pyunits.m 3,\n bounds=(990, 1200),\n doc='Density of NaCl regen solution [kg/m3]')\n\n self.regen_ww = Var(time,\n initialize=0.1,\n domain=NonNegativeReals,\n bounds=(0.015, 0.26),\n doc='Strength of NaCl solution w/w [kg NaCl/kg soln]')\n\n self.regen_conc = Var(time,\n initialize=110,\n domain=NonNegativeReals,\n units=pyunits.kg / pyunits.m 3,\n doc='Concentration of regen solution [kg/m3]')\n\n self.regen_vol = Var(time,\n initialize=2,\n domain=NonNegativeReals,\n doc='m3 of regen solution per m3 resin')\n\n self.regen_soln_per_column = Var(time,\n initialize=50,\n domain=NonNegativeReals,\n units=pyunits.m 3,\n doc='Regen solution used per column [m3/column]')\n\n self.regen_soln_per_column_annual = Var(time,\n initialize=1E3,\n domain=NonNegativeReals,\n units=pyunits.m 3 / pyunits.year,\n doc='Annual regen used per column [m3/year]')\n\n self.regen_soln_annual = Var(time,\n initialize=1E5,\n domain=NonNegativeReals,\n units=pyunits.m 3 / pyunits.year,\n doc='Total volume regen solution used [m3/year]')\n\n self.regen_time_per_column = Var(time,\n initialize=5,\n domain=NonNegativeReals,\n units=pyunits.min,\n doc='Regen time per column [min]')\n\n self.regen_flow = Var(time,\n initialize=10,\n domain=NonNegativeReals,\n units=pyunits.m 3 / pyunits.min,\n doc='Regeneration flow rate [m3/min]')\n\n self.num_regen_per_column_annual = Var(time,\n initialize=200,\n domain=NonNegativeReals,\n doc='Number of regen cycles per year')\n\n self.salt_per_regen_per_column = Var(time,\n initialize=5E3,\n domain=NonNegativeReals,\n doc='Number of regen cycles per year')\n\n self.salt_per_column_annual = Var(time,\n initialize=1E5,\n domain=NonNegativeReals,\n units=pyunits.kg / pyunits.year,\n doc='Mass of salt per column per year [kg/yr]')\n\n self.salt_total_annual = Var(time,\n initialize=1E6,\n domain=NonNegativeReals,\n units=pyunits.kg / pyunits.year,\n doc='Mass of salt per year [kg/yr]')\n\n self.salt_dose = Var(time,\n initialize=0.1,\n domain=NonNegativeReals,\n units=pyunits.kg / pyunits.m 3,\n doc='Salt dose for system [kg/m3]')\n\n self.total_regen_time = Var(time,\n initialize=30,\n units=pyunits.min,\n domain=NonNegativeReals,\n doc='Total regeneration cycle time [min]')\n\n self.regen_dose.fix(300)\n\n try:\n self.regen_ww.fix(unit_params['regen_ww'])\n except KeyError:\n self.regen_ww.fix(0.1)\n\n ### BACKWASH VARIABLES\n\n self.bw_rate = Var(time,\n initialize=5,\n domain=NonNegativeReals,\n units=pyunits.m / pyunits.hour,\n bounds=(4.5, 6.5),\n doc='Backwash rate [m/hr]')\n\n self.bw_time = Var(time,\n initialize=6,\n domain=NonNegativeReals,\n units=pyunits.minute,\n bounds=(4, 15),\n doc='Backwash time [min]')\n\n self.bw_flow = Var(time,\n initialize=5,\n domain=NonNegativeReals,\n units=pyunits.m 3 / pyunits.minute,\n doc='Backwash flow rate [m3/min]')\n\n self.bed_expansion = Var(time,\n initialize=0.5,\n domain=NonNegativeReals,\n units=pyunits.dimensionless,\n bounds=(0.4, 0.6),\n doc='Resin bed expansion during backwash [%]')\n\n self.bed_expansion_h = Var(time,\n # initialize=0.5,\n domain=NonNegativeReals,\n units=pyunits.m,\n bounds=(0.1, 3),\n doc='Resin bed expansion during backwash [m]')\n\n self.bw_time.fix(6)\n\n ### RINSE VARIABLES\n\n self.rinse_bv = Var(time,\n initialize=5,\n domain=NonNegativeReals,\n bounds=(2, 5),\n doc='Number of bed volumes for rinse step [BV]')\n\n self.rinse_vol_per_column = Var(time,\n initialize=150,\n domain=NonNegativeReals,\n units=pyunits.m 3,\n doc='Rinse volume per column [m3/col]')\n\n self.rinse_vol_per_column_annual = Var(time,\n initialize=5E3,\n domain=NonNegativeReals,\n units=pyunits.m 3 / pyunits.year,\n doc='Rinse volume per column [m3/yr]')\n\n self.rinse_time_per_column = Var(time,\n initialize=4,\n domain=NonNegativeReals,\n units=pyunits.min,\n doc='Rinse time per column [min]')\n\n self.rinse_flow = Var(time,\n initialize=2,\n domain=NonNegativeReals,\n units=pyunits.m 3 / pyunits.min,\n doc='Rinse step flow rate [m3/min]')\n\n self.rinse_bv.fix(3)\n\n ### RESIN AND FLOW VARIABLES\n\n ix_df = self.ix_df = pd.read_csv('data/ix_sac.csv', index_col='constituent')\n self.cons = [c for c in self.config.property_package.component_list if c in ix_df.index]\n ix_df = self.ix_df = ix_df.loc[self.cons].copy()\n self.sep_factor_dict = ix_df.to_dict()['sep_factor']\n self.meq_conv_dict = ix_df.to_dict()['meq']\n\n try:\n self.target = unit_params['target']\n except KeyError:\n self.cons_df = self.source_df.loc[[c for c in self.cons if c != 'sodium']].copy()\n self.cons_df['meq_L'] = [(self.cons_df.loc[c].value * 1E3) / self.meq_conv_dict[c] for c in self.cons if c != 'sodium']\n self.target = self.cons_df.meq_L.idxmax()\n\n for k, v in self.sep_factor_dict.items():\n if v > self.sep_factor_dict[self.target]:\n self.sep_factor_dict[k] = 0.99 * self.sep_factor_dict[self.target]\n\n self.sep_factor = Param(self.cons,\n initialize=self.sep_factor_dict)\n\n self.meq_conv = Param(self.cons,\n initialize=self.meq_conv_dict)\n\n self.target_removal = Var(time,\n initialize=1,\n domain=NonNegativeReals,\n bounds=(0.0001, 1),\n doc='Removal fraction for target compound')\n\n self.sfr = Var(time,\n initialize=30,\n domain=NonNegativeReals,\n bounds=(6, 50),\n doc='Service flow rate [BV/hr]')\n\n self.loading_rate = Var(time,\n initialize=20,\n domain=NonNegativeReals,\n bounds=(10, 40),\n units=pyunits.m / pyunits.hr,\n doc='Column loading rate (superficial velocity) [m/hr]')\n\n self.cycle_time = Var(time,\n initialize=100,\n domain=NonNegativeReals,\n units=pyunits.hr,\n doc='Service cycle time [hr]')\n\n self.ebct = Var(time,\n initialize=1.1,\n domain=NonNegativeReals,\n units=pyunits.min,\n doc='Empty Bed Contact Time [min]')\n\n self.mg_L = Var(time,\n self.cons,\n initialize=1,\n domain=NonNegativeReals,\n doc='Influent concentration in mg/L')\n\n self.meq_L = Var(time,\n self.cons,\n initialize=0.1,\n domain=NonNegativeReals,\n doc='Influent concentration in meq/L')\n\n self.mass_in = Var(time,\n self.cons,\n initialize=200,\n domain=NonNegativeReals,\n doc='Influent mass [eq]')\n\n self.mass_removed = Var(time,\n self.cons,\n initialize=10,\n domain=NonNegativeReals,\n doc='Mass removed [eq]')\n\n self.frac_removed = Var(time,\n self.cons,\n initialize=0.8,\n domain=NonNegativeReals,\n doc='Fraction removed [%]')\n\n self.denom_resin = Var(time,\n initialize=1,\n domain=NonNegativeReals)\n\n self.denom_aq = Var(time,\n initialize=1,\n domain=NonNegativeReals)\n\n self.resin_conc = Var(time,\n self.cons,\n initialize=0.1,\n domain=NonNegativeReals,\n doc='Resin phase concentration of each ion [eq/L resin]')\n\n self.max_vol_treated = Var(time,\n initialize=5E3,\n domain=NonNegativeReals,\n bounds=(100, 1E6),\n units=pyunits.L / pyunits.L,\n doc='Max volume of water treated before breakthrough [L water/L resin]')\n\n self.resin_capacity = Var(time,\n initialize=1.7,\n domain=NonNegativeReals,\n bounds=(1.6, 2.2),\n doc='Resin capacity [eq/L]')\n\n self.resin_vol = Var(time,\n # initialize=100,\n domain=NonNegativeReals,\n units=pyunits.m 3,\n doc='Resin volume needed [m3]')\n\n self.resin_area = Var(time,\n initialize=100,\n domain=NonNegativeReals,\n units=pyunits.m 2,\n doc='Resin cross-sectional area needed [m2]')\n\n self.resin_depth = Var(time,\n initialize=1.5,\n domain=NonNegativeReals,\n bounds=(0.75, 3),\n units=pyunits.m,\n doc='Resin bed depth [m]')\n\n self.resin_depth_to_column_diam_ratio = Var(time,\n initialize=1,\n domain=NonNegativeReals,\n bounds=(0.6, 1.6),\n units=pyunits.dimensionless,\n doc='Ratio of resin depth to column height')\n\n self.resin_per_column = Var(time,\n initialize=15,\n domain=NonNegativeReals,\n units=pyunits.m 3,\n doc='Resin per column [m3]')\n\n self.resin_loss_frac_annual = Var(time,\n initialize=0.045,\n domain=NonNegativeReals,\n bounds=(3.75, 5.25),\n doc='Fraction of resin replaced per year [%]')\n\n self.resin_loss_annual = Var(time,\n initialize=20,\n domain=NonNegativeReals,\n units=pyunits.m 3,\n doc='Resin replaced per year [m3]')\n\n #### COLUMN VARIABLES\n\n self.column_h = Var(time,\n initialize=2,\n domain=NonNegativeReals,\n units=pyunits.m,\n bounds=(1, 16),\n doc='Column height [m]')\n\n self.column_diam = Var(time,\n initialize=2,\n domain=NonNegativeReals,\n units=pyunits.m,\n bounds=(1, 4),\n doc='Column diameter [m]')\n\n self.column_area = Var(time,\n initialize=15,\n domain=NonNegativeReals,\n units=pyunits.m 2,\n doc='Column cross-sectional area [m2]')\n\n if self.pv_material == 'fiberglass':\n self.column_vol = Var(time,\n initialize=2,\n domain=NonNegativeReals,\n bounds=(0.5, 4),\n units=pyunits.m 3,\n doc='Column volume [m3]')\n\n else:\n self.column_vol = Var(time,\n initialize=35,\n domain=NonNegativeReals,\n bounds=(0.5, 25),\n units=pyunits.m 3,\n doc='Column volume [m3]')\n\n self.num_columns = Var(time,\n initialize=2,\n domain=NonNegativeReals,\n bounds=(1, 1E5),\n units=pyunits.dimensionless,\n doc='Number of columns in parallel')\n\n self.underdrain_h = Var(time,\n initialize=0.5,\n domain=NonNegativeReals,\n units=pyunits.m,\n doc='Underdrain height [m]')\n\n self.distributor_h = Var(time,\n initialize=1,\n domain=NonNegativeReals,\n units=pyunits.m,\n doc='Distributor height [m]')\n\n self.flow_per_column = Var(time,\n initialize=250,\n domain=NonNegativeReals,\n units=pyunits.m 3 / pyunits.hr,\n doc='Flow per column [m3/hr]')\n\n self.pressure_drop = Var(time,\n initialize=14,\n domain=NonNegativeReals,\n units=pyunits.psi,\n bounds=(0, 25),\n doc='Pressure drop across column [psi]')\n\n self.resin_capacity.fix(1.7)\n # self.sfr.fix(30)\n self.loading_rate.fix(20)\n self.underdrain_h.fix(0.5)\n self.distributor_h.fix(1)\n self.resin_loss_frac_annual.fix(0.045)\n # self.column_diam.fix(2.5)\n\n try:\n self.target_removal = unit_params['target_removal']\n except KeyError:\n self.target_removal.fix(1)\n\n flow_out_m3_hr = pyunits.convert(self.flow_vol_out[self.t], to_units=pyunits.m 3 / pyunits.hr)\n flow_out_m3_yr = pyunits.convert(self.flow_vol_out[self.t], to_units=pyunits.m 3 / pyunits.year)\n flow_out_L_hr = pyunits.convert(self.flow_vol_out[self.t], to_units=pyunits.L / pyunits.hr)\n\n ############################# CONSTRAINTS START\n #### RESIN AND PERFORMANCE CONSTRAINTS\n\n self.mg_L_constr = ConstraintList()\n self.meq_L_constr = ConstraintList()\n self.resin_conc_constr = ConstraintList()\n self.mass_in_constr = ConstraintList()\n self.mass_removed_constr = ConstraintList()\n self.frac_removed_constr = ConstraintList()\n\n for c in self.cons:\n self.mg_L_constr.add(self.mg_L[self.t, c] == (self.conc_mass_in[self.t, c] * 1E3))\n self.meq_L_constr.add(self.meq_L[self.t, c] == self.mg_L[self.t, c] / self.meq_conv[c])\n self.resin_conc_constr.add(self.resin_conc[self.t, c] == (self.resin_capacity[self.t] * self.sep_factor[c] * self.meq_L[self.t, c]) /\n self.denom_resin[self.t])\n self.mass_in_constr.add(self.mass_in[self.t, c] == self.meq_L[self.t, c] * flow_out_m3_hr * self.cycle_time[self.t] * 1E-3)\n self.mass_removed_constr.add(self.mass_removed[self.t, c] == (self.resin_conc[self.t, c] / self.max_vol_treated[self.t]) * flow_out_m3_hr * self.cycle_time[self.t])\n self.frac_removed_constr.add(self.frac_removed[self.t, c] == 0.99 * (self.mass_removed[self.t, c] / self.mass_in[self.t, c]))\n\n self.denom_resin_constr = Constraint(expr=self.denom_resin[self.t] == sum(self.meq_L[self.t, c] * self.sep_factor[c] for c in self.cons))\n self.denom_aq_constr = Constraint(expr=self.denom_aq[self.t] == sum(self.resin_conc[self.t, c] / self.sep_factor[c] for c in self.cons))\n\n self.max_vol_treated_constr = Constraint(expr=self.max_vol_treated[self.t] == (self.resin_conc[self.t, self.target] * 1E3) /\n (self.meq_L[self.t, self.target] * self.target_removal[self.t]))\n\n self.resin_vol_constr = Constraint(expr=self.resin_vol[self.t] == flow_out_m3_hr / self.sfr[self.t])\n resin_vol_L = pyunits.convert(self.resin_vol[self.t], to_units=pyunits.L)\n\n self.resin_depth_to_column_diam_ratio_constr = Constraint(expr=self.resin_depth_to_column_diam_ratio[self.t] == self.resin_depth[self.t] / self.column_diam[self.t])\n\n self.resin_loss_annual_constr = Constraint(expr=self.resin_loss_annual[self.t] == self.resin_vol[self.t] * self.resin_loss_frac_annual[self.t])\n\n self.cycle_time_constr = Constraint(expr=self.cycle_time[self.t] == (self.max_vol_treated[self.t] * resin_vol_L) / flow_out_L_hr)\n\n self.resin_area_constr = Constraint(expr=self.resin_area[self.t] == self.resin_vol[self.t] / self.resin_depth[self.t])\n\n self.column_area_constr = Constraint(expr=self.column_area[self.t] == 3.141592 * (self.column_diam[self.t] / 2) ** 2)\n\n self.num_columns_constr = Constraint(expr=self.num_columns[self.t] == self.resin_area[self.t] / self.column_area[self.t])\n\n self.flow_per_col_constr = Constraint(expr=self.flow_per_column[self.t] == flow_out_m3_hr / self.num_columns[self.t])\n\n self.resin_per_col_constr = Constraint(expr=self.resin_per_column[self.t] == self.resin_vol[self.t] / self.num_columns[self.t])\n\n self.loading_rate_constr1 = Constraint(expr=self.loading_rate[self.t] == self.flow_per_column[self.t] / self.column_area[self.t])\n self.loading_rate_constr2 = Constraint(expr=self.loading_rate[self.t] == self.sfr[self.t] * self.resin_depth[self.t])\n\n self.pressure_drop_constr = Constraint(expr=self.pressure_drop[self.t] == (8.28E-04 * self.loading_rate[self.t] ** 2 + 0.173 * self.loading_rate[self.t] + 0.609) * self.resin_depth[self.t]) # Curve for 20C temperatuer\n\n self.column_h_constr = Constraint(expr=self.column_h[self.t] == self.resin_depth[self.t] + self.bed_expansion_h[self.t] + self.distributor_h[self.t] + self.underdrain_h[self.t])\n\n self.column_vol_constr = Constraint(expr=self.column_vol[self.t] == 3.14159 * (self.column_diam[self.t] / 2) ** 2 * self.column_h[self.t])\n\n self.ebct_constr = Constraint(expr=self.ebct[self.t] == (self.resin_depth[self.t] / self.loading_rate[self.t]) * 60)\n\n #### REGEN CONSTRAINTS\n\n self.regen_density_constr = Constraint(expr=self.regen_density[self.t] == 994.34 + 761.65 * self.regen_ww[self.t]) # kg Nacl / m3 resin\n\n self.regen_conc_constr = Constraint(expr=self.regen_conc[self.t] == self.regen_ww[self.t] * self.regen_density[self.t])\n\n self.regen_vol_constr = Constraint(expr=self.regen_vol[self.t] == self.regen_dose[self.t] / self.regen_conc[self.t]) # m3 regen soln / m3 resin\n\n self.num_regen_per_column_annual_constr = Constraint(expr=self.num_regen_per_column_annual[self.t] == 8760 / self.cycle_time[self.t]) # numerator is hours per year\n\n self.salt_per_regen_per_column_constr = Constraint(expr=self.salt_per_regen_per_column[self.t] == self.resin_per_column[self.t] * self.regen_dose[self.t])\n\n self.salt_per_col_annual_constr = Constraint(expr=self.salt_per_column_annual[self.t] == self.num_regen_per_column_annual[self.t] * self.salt_per_regen_per_column[self.t]) # kg / year per column\n\n self.salt_total_annual_constr = Constraint(expr=self.salt_total_annual[self.t] == self.salt_per_column_annual[self.t] * self.num_columns[self.t]) # kg / year\n\n self.salt_dose_constr = Constraint(expr=self.salt_dose[self.t] == self.salt_total_annual[self.t] / flow_out_m3_yr)\n\n self.regen_soln_per_col_constr = Constraint(expr=self.regen_soln_per_column[self.t] == self.resin_per_column[self.t] * self.regen_vol[self.t])\n\n self.regen_soln_per_col_annual_constr = Constraint(expr=self.regen_soln_per_column_annual[self.t] == self.regen_soln_per_column[self.t] * self.num_regen_per_column_annual[self.t])\n\n self.regen_soln_annual_constr = Constraint(expr=self.regen_soln_annual[self.t] == self.regen_soln_per_column_annual[self.t] * self.num_columns[self.t])\n\n self.regen_time_per_col_constr = Constraint(expr=self.regen_time_per_column[self.t] == self.ebct[self.t] * self.regen_vol[self.t])\n\n self.total_regen_time_constr = Constraint(expr=self.total_regen_time[self.t] == self.regen_time_per_column[self.t] + self.rinse_time_per_column[self.t] + self.bw_time[self.t])\n\n self.regen_flow_constr = Constraint(expr=self.regen_flow[self.t] == self.column_vol[self.t] / self.regen_time_per_column[self.t])\n\n ##### BW CONSTRAINTS\n\n self.bed_exp_constr = Constraint(expr=self.bed_expansion[self.t] == -1.35E-3 * self.bw_rate[self.t] ** 2 + 1.02E-1 * self.bw_rate[self.t] - 1.23E-2)\n\n self.bed_exp_h_constr = Constraint(expr=self.bed_expansion_h[self.t] == self.resin_depth[self.t] * self.bed_expansion[self.t])\n\n self.bw_flow_constr = Constraint(expr=self.bw_flow[self.t] == self.column_vol[self.t] / self.bw_time[self.t])\n\n ##### RINSE CONSTRAINTS\n\n self.rinse_vol_per_column_constr = Constraint(expr=self.rinse_vol_per_column[self.t] == self.resin_per_column[self.t] * self.rinse_bv[self.t])\n\n self.rinse_vol_per_col_annual_constr = Constraint(expr=self.rinse_vol_per_column_annual[self.t] == self.rinse_vol_per_column[self.t] * self.num_regen_per_column_annual[self.t])\n\n self.rinse_time_per_col_constr = Constraint(expr=self.rinse_time_per_column[self.t] == self.ebct[self.t] * self.rinse_bv[self.t])\n\n self.rinse_flow_constr = Constraint(expr=self.rinse_flow[self.t] == self.column_vol[self.t] / self.rinse_time_per_column[self.t])\n\n ##### WATER RECOVERY, CHEM DICT, AND CONSTITUENT REMOVAL\n\n self.wr_constr = Constraint(expr=self.water_recovery[self.t] == 1 - (self.total_regen_time[self.t] / ((self.cycle_time[self.t] * 60) + self.total_regen_time[self.t])))\n\n self.chem_dict = {\n 'Sodium_Chloride': self.salt_dose[self.t]\n }\n\n self.del_component(self.component_removal_equation)\n\n self.ix_component_removal = ConstraintList()\n for c in self.config.property_package.component_list:\n if c in self.cons:\n self.ix_component_removal.add(self.frac_removed[self.t, c] * self.flow_vol_in[self.t] * self.conc_mass_in[self.t, c] ==\n self.flow_vol_waste[self.t] * self.conc_mass_waste[self.t, c])\n else:\n self.ix_component_removal.add(self.removal_fraction[self.t, c] * self.flow_vol_in[self.t] * self.conc_mass_in[self.t, c] ==\n self.flow_vol_waste[self.t] * self.conc_mass_waste[self.t, c])\n\n def get_costing(self, unit_params=None, year=None):\n '''\n Initialize the unit in WaterTAP3.\n '''\n financials.create_costing_block(self, basis_year, tpec_or_tic)\n time = self.flowsheet().config.time\n self.t = time.first()\n self.units_meta = self.config.property_package.get_metadata().get_derived_units\n\n self.mode = unit_params['mode']\n self.source_df = self.parent_block().source_df\n self.parent_block().has_ix = True\n try:\n self.pv_material = unit_params['pv_material']\n except KeyError:\n self.pv_material = 'carbon_w_plastic_internals'\n\n\n\n if self.mode == 'sac':\n self.resin_dict = {\n 'polystyrenic_macro': 3680,\n 'polystyrenic_gel': 6240,\n } # cost of resin per m3, adapted to $/m3 from EPA models\n\n try:\n self.resin_type = unit_params['resin_type']\n except KeyError:\n self.resin_type = 'polystyrenic_macro'\n self.sac(unit_params)\n\n if self.mode == 'sba':\n self.resin_dict = {\n 'styrenic_gel_1': 5214,\n 'styrenic_gel_2': 6116,\n 'styrenic_macro_1': 7298,\n 'styrenic_macro_2': 7810,\n 'polyacrylic': 8658,\n 'nitrate': 6116\n } # cost of resin per m3, adapted to $/m3 from EPA models\n try:\n self.resin_type = unit_params['resin_type']\n except KeyError:\n self.resin_type = 'styrenic_gel_1'\n self.sba(unit_params)\n\n\n\n self.costing.fixed_cap_inv_unadjusted = Expression(expr=self.fixed_cap(unit_params),\n doc='Unadjusted fixed capital investment')\n self.electricity = Expression(expr=self.elect(),\n doc='Electricity intensity [kwh/m3]')\n\n self.costing.other_var_cost = (self.resin_unit_cap[self.t] * self.resin_loss_annual[self.t]) * 1E-6\n financials.get_complete_costing(self.costing)" ]	[ [ "pandas.read_csv" ] ]
mateus2810/atividadesIa	[ "0ffc816c962889fb9e0b9635692d616e46a0d0c5" ]	[ "atividade2/RetornarVerticesAdjacentes.py" ]	[ "#Questão 7 - Retornar os vertes adjacentes\n\nimport numpy as np\n\nmatrixIa = [[0,5,0,0,15,2], [5,0,0,9,22,4], [0,0,0,13,1,0], [9,0,12,0,0,6], [15,22,1,0,0,0], [2,4,0,6,0,0]]\n#Mostrar os vertes adjacentes ]\n\nprint(np.matrix(matrixIa))\n" ]	[ [ "numpy.matrix" ] ]
wbernoudy/dimod	[ "c39677b4a743574dc795bc140dce703abd61087b" ]	[ "dimod/utilities.py" ]	[ "# Copyright 2018 D-Wave Systems Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport copy\nimport os\nimport itertools\n\nfrom functools import reduce\n\nimport numpy as np\n\n__all__ = ['ising_energy',\n 'qubo_energy',\n 'ising_to_qubo',\n 'qubo_to_ising',\n 'child_structure_dfs',\n 'get_include',\n ]\n\n\ndef ising_energy(sample, h, J, offset=0.0):\n \"\"\"Calculate the energy for the specified sample of an Ising model.\n\n Energy of a sample for a binary quadratic model is defined as a sum, offset\n by the constant energy offset associated with the model, of\n the sample multipled by the linear bias of the variable and\n all its interactions. For an Ising model,\n\n .. math::\n\n E(\\mathbf{s}) = \\sum_v h_v s_v + \\sum_{u,v} J_{u,v} s_u s_v + c\n\n where :math:`s_v` is the sample, :math:`h_v` is the linear bias, :math:`J_{u,v}`\n the quadratic bias (interactions), and :math:`c` the energy offset.\n\n Args:\n sample (dict[variable, spin]):\n Sample for a binary quadratic model as a dict of form {v: spin, ...},\n where keys are variables of the model and values are spins (either -1 or 1).\n h (dict[variable, bias]):\n Linear biases as a dict of the form {v: bias, ...}, where keys are variables of\n the model and values are biases.\n J (dict[(variable, variable), bias]):\n Quadratic biases as a dict of the form {(u, v): bias, ...}, where keys\n are 2-tuples of variables of the model and values are quadratic biases\n associated with the pair of variables (the interaction).\n offset (numeric, optional, default=0):\n Constant offset to be applied to the energy. Default 0.\n\n Returns:\n float: The induced energy.\n\n Notes:\n No input checking is performed.\n\n Examples:\n This example calculates the energy of a sample representing two down spins for\n an Ising model of two variables that have positive biases of value 1 and\n are positively coupled with an interaction of value 1.\n\n >>> sample = {1: -1, 2: -1}\n >>> h = {1: 1, 2: 1}\n >>> J = {(1, 2): 1}\n >>> dimod.ising_energy(sample, h, J, 0.5)\n -0.5\n\n References\n ----------\n\n `Ising model on Wikipedia <https://en.wikipedia.org/wiki/Ising_model>`_\n\n \"\"\"\n # add the contribution from the linear biases\n for v in h:\n offset += h[v] * sample[v]\n\n # add the contribution from the quadratic biases\n for v0, v1 in J:\n offset += J[(v0, v1)] * sample[v0] * sample[v1]\n\n return offset\n\n\ndef qubo_energy(sample, Q, offset=0.0):\n \"\"\"Calculate the energy for the specified sample of a QUBO model.\n\n Energy of a sample for a binary quadratic model is defined as a sum, offset\n by the constant energy offset associated with the model, of\n the sample multipled by the linear bias of the variable and\n all its interactions. For a quadratic unconstrained binary optimization (QUBO)\n model,\n\n .. math::\n\n E(\\mathbf{x}) = \\sum_{u,v} Q_{u,v} x_u x_v + c\n\n where :math:`x_v` is the sample, :math:`Q_{u,v}`\n a matrix of biases, and :math:`c` the energy offset.\n\n Args:\n sample (dict[variable, spin]):\n Sample for a binary quadratic model as a dict of form {v: bin, ...},\n where keys are variables of the model and values are binary (either 0 or 1).\n Q (dict[(variable, variable), coefficient]):\n QUBO coefficients in a dict of form {(u, v): coefficient, ...}, where keys\n are 2-tuples of variables of the model and values are biases\n associated with the pair of variables. Tuples (u, v) represent interactions\n and (v, v) linear biases.\n offset (numeric, optional, default=0):\n Constant offset to be applied to the energy. Default 0.\n\n Returns:\n float: The induced energy.\n\n Notes:\n No input checking is performed.\n\n Examples:\n This example calculates the energy of a sample representing two zeros for\n a QUBO model of two variables that have positive biases of value 1 and\n are positively coupled with an interaction of value 1.\n\n >>> sample = {1: 0, 2: 0}\n >>> Q = {(1, 1): 1, (2, 2): 1, (1, 2): 1}\n >>> dimod.qubo_energy(sample, Q, 0.5)\n 0.5\n\n References\n ----------\n\n `QUBO model on Wikipedia <https://en.wikipedia.org/wiki/Quadratic_unconstrained_binary_optimization>`_\n\n \"\"\"\n for v0, v1 in Q:\n offset += sample[v0] * sample[v1] * Q[(v0, v1)]\n\n return offset\n\n\ndef ising_to_qubo(h, J, offset=0.0):\n \"\"\"Convert an Ising problem to a QUBO problem.\n\n Map an Ising model defined on spins (variables with {-1, +1} values) to quadratic\n unconstrained binary optimization (QUBO) formulation :math:`x' Q x` defined over\n binary variables (0 or 1 values), where the linear term is contained along the diagonal of Q.\n Return matrix Q that defines the model as well as the offset in energy between the two\n problem formulations:\n\n .. math::\n\n s' J s + h' s = offset + x' Q x\n\n See :meth:`~dimod.utilities.qubo_to_ising` for the inverse function.\n\n Args:\n h (dict[variable, bias]):\n Linear biases as a dict of the form {v: bias, ...}, where keys are variables of\n the model and values are biases.\n J (dict[(variable, variable), bias]):\n Quadratic biases as a dict of the form {(u, v): bias, ...}, where keys\n are 2-tuples of variables of the model and values are quadratic biases\n associated with the pair of variables (the interaction).\n offset (numeric, optional, default=0):\n Constant offset to be applied to the energy. Default 0.\n\n Returns:\n (dict, float): A 2-tuple containing:\n\n dict: QUBO coefficients.\n\n float: New energy offset.\n\n Examples:\n This example converts an Ising problem of two variables that have positive\n biases of value 1 and are positively coupled with an interaction of value 1\n to a QUBO problem and prints the resulting energy offset.\n\n >>> h = {1: 1, 2: 1}\n >>> J = {(1, 2): 1}\n >>> dimod.ising_to_qubo(h, J, 0.5)[1]\n -0.5\n\n \"\"\"\n # the linear biases are the easiest\n q = {(v, v): 2. * bias for v, bias in h.items()}\n\n # next the quadratic biases\n for (u, v), bias in J.items():\n if bias == 0.0:\n continue\n q[(u, v)] = 4. * bias\n q[(u, u)] = q.setdefault((u, u), 0) - 2. * bias\n q[(v, v)] = q.setdefault((v, v), 0) - 2. * bias\n\n # finally calculate the offset\n offset += sum(J.values()) - sum(h.values())\n\n return q, offset\n\n\ndef qubo_to_ising(Q, offset=0.0):\n \"\"\"Convert a QUBO problem to an Ising problem.\n\n Map a quadratic unconstrained binary optimization (QUBO) problem :math:`x' Q x`\n defined over binary variables (0 or 1 values), where the linear term is contained along\n the diagonal of Q, to an Ising model defined on spins (variables with {-1, +1} values).\n Return h and J that define the Ising model as well as the offset in energy\n between the two problem formulations:\n\n .. math::\n\n x' Q x = offset + s' J s + h' s\n\n See :meth:`~dimod.utilities.ising_to_qubo` for the inverse function.\n\n Args:\n Q (dict[(variable, variable), coefficient]):\n QUBO coefficients in a dict of form {(u, v): coefficient, ...}, where keys\n are 2-tuples of variables of the model and values are biases\n associated with the pair of variables. Tuples (u, v) represent interactions\n and (v, v) linear biases.\n offset (numeric, optional, default=0):\n Constant offset to be applied to the energy. Default 0.\n\n Returns:\n (dict, dict, float): A 3-tuple containing:\n\n dict: Linear coefficients of the Ising problem.\n\n dict: Quadratic coefficients of the Ising problem.\n\n float: New energy offset.\n\n Examples:\n This example converts a QUBO problem of two variables that have positive\n biases of value 1 and are positively coupled with an interaction of value 1\n to an Ising problem, and shows the new energy offset.\n\n >>> Q = {(1, 1): 1, (2, 2): 1, (1, 2): 1}\n >>> dimod.qubo_to_ising(Q, 0.5)[2]\n 1.75\n\n \"\"\"\n h = {}\n J = {}\n linear_offset = 0.0\n quadratic_offset = 0.0\n\n for (u, v), bias in Q.items():\n if u == v:\n if u in h:\n h[u] += .5 * bias\n else:\n h[u] = .5 * bias\n linear_offset += bias\n\n else:\n if bias != 0.0:\n J[(u, v)] = .25 * bias\n\n if u in h:\n h[u] += .25 * bias\n else:\n h[u] = .25 * bias\n\n if v in h:\n h[v] += .25 * bias\n else:\n h[v] = .25 * bias\n\n quadratic_offset += bias\n\n offset += .5 * linear_offset + .25 * quadratic_offset\n\n return h, J, offset\n\n\ndef resolve_label_conflict(mapping, existing, old_labels=None, new_labels=None):\n \"\"\"Resolve a self-labeling conflict by creating an intermediate labeling.\n\n Args:\n mapping (dict):\n A dict mapping the current variable labels to new ones.\n\n existing (set-like):\n The existing labels.\n\n old_labels (set, optional, default=None):\n The keys of mapping. Can be passed in for performance reasons. These are not checked.\n\n new_labels (set, optional, default=None):\n The values of mapping. Can be passed in for performance reasons. These are not checked.\n\n Returns:\n tuple: A 2-tuple containing:\n\n dict: A map from the keys of mapping to an intermediate labeling\n\n dict: A map from the intermediate labeling to the values of mapping.\n\n \"\"\"\n\n if old_labels is None:\n old_labels = set(mapping)\n if new_labels is None:\n new_labels = set(mapping.values())\n\n # counter will be used to generate the intermediate labels, as an easy optimization\n # we start the counter with a high number because often variables are labeled by\n # integers starting from 0\n counter = itertools.count(2 * len(mapping))\n\n old_to_intermediate = {}\n intermediate_to_new = {}\n\n for old, new in mapping.items():\n if old == new:\n # we can remove self-labels\n continue\n\n if old in new_labels or new in old_labels:\n\n # try to get a new unique label\n lbl = next(counter)\n while lbl in new_labels or lbl in old_labels or lbl in existing:\n lbl = next(counter)\n\n # add it to the mapping\n old_to_intermediate[old] = lbl\n intermediate_to_new[lbl] = new\n\n else:\n old_to_intermediate[old] = new\n # don't need to add it to intermediate_to_new because it is a self-label\n\n return old_to_intermediate, intermediate_to_new\n\n\ndef iter_safe_relabels(mapping, existing):\n \"\"\"Iterator over \"safe\" intermediate relabelings.\n\n Args:\n mapping (dict):\n A map from old labels to new.\n\n existing (set):\n A container of existing labels.\n\n Yields:\n dict: A \"safe\" relabelling.\n\n \"\"\"\n\n # put the new labels into a set for fast lookup, also ensures that the\n # values are valid labels\n try:\n new_labels = set(mapping.values())\n except TypeError:\n raise ValueError(\"mapping targets must be hashable objects\")\n\n old_labels = mapping.keys()\n\n for v in new_labels:\n if v in existing and v not in old_labels:\n msg = (\"A variable cannot be relabeled {!r} without also \"\n \"relabeling the existing variable of the same name\")\n raise ValueError(msg.format(v))\n\n if any(v in new_labels for v in old_labels):\n yield from resolve_label_conflict(mapping, existing, old_labels, new_labels)\n else:\n yield mapping\n\n\ndef child_structure_dfs(sampler, seen=None):\n \"\"\"Return the structure of a composed sampler using a depth-first search on its\n children.\n\n Args:\n sampler (:obj:`.Sampler`):\n :class:`.Structured` or composed sampler with at least\n one structured child.\n\n seen (set, optional, default=False):\n IDs of already checked child samplers.\n\n Returns:\n :class:`~collections.namedtuple`: A named tuple of the form\n `Structure(nodelist, edgelist, adjacency)`, where the 3-tuple values\n are the :attr:`.Structured.nodelist`, :attr:`.Structured.edgelist`\n and :attr:`.Structured.adjacency` attributes of the first structured\n sampler found.\n\n Raises:\n ValueError: If no structured sampler is found.\n\n Examples:\n\n >>> sampler = dimod.TrackingComposite(\n ... dimod.StructureComposite(\n ... dimod.ExactSolver(), [0, 1], [(0, 1)]))\n >>> print(dimod.child_structure_dfs(sampler).nodelist)\n [0, 1]\n\n\n \"\"\"\n seen = set() if seen is None else seen\n\n if sampler not in seen:\n try:\n return sampler.structure\n except AttributeError:\n # hasattr just tries to access anyway...\n pass\n\n seen.add(sampler)\n\n for child in getattr(sampler, 'children', ()): # getattr handles samplers\n if child in seen:\n continue\n\n try:\n return child_structure_dfs(child, seen=seen)\n except ValueError:\n # tree has no child samplers\n pass\n\n raise ValueError(\"no structured sampler found\")\n\n\ndef get_include():\n \"\"\"Return the directory with dimod's header files.\"\"\"\n return os.path.join(os.path.dirname(__file__), 'include')\n\n\ndef _astypearrays(arrays, requirements, min_itemsize, allowed_types):\n # allowed types can only be numeric for now, see comment below\n # todo: allow unsafe with warning controlled by kwarg?\n\n # We need to get the dtype, and as far as I can tell the only way to do\n # it for array-like is to actually cast to a numpy array\n arrays = [np.asarray(arr) for arr in arrays]\n\n # get the dtype we can promote to\n dtype = reduce(np.promote_types, (arr.dtype for arr in arrays))\n\n if not any(np.issubdtype(dtype, type_) for type_ in allowed_types):\n # put together an appropriate error message\n descriptors = []\n if np.floating in allowed_types:\n descriptors.append('floating')\n if np.integer in allowed_types:\n descriptors.append('integer')\n elif np.unsignedinteger in allowed_types:\n if np.signedinteger in allowed_types:\n descriptors.append('integer')\n else:\n descriptors.append('unsigned integer')\n elif np.signedinteger in allowed_types:\n descriptors.append('signed integer')\n\n raise TypeError(\n \"Cannot safely cast arrays to {} (given {})\".format(\n ', '.join(descriptors),\n ', '.join(arr.dtype.name for arr in arrays)))\n\n if min_itemsize is not None:\n if min_itemsize >= 1:\n size = str(2*int(np.ceil(np.log2(min_itemsize))))\n else:\n size = '1'\n if np.issubdtype(dtype, np.unsignedinteger):\n kind = 'u'\n elif np.issubdtype(dtype, np.signedinteger):\n kind = 'i'\n elif np.issubdtype(dtype, np.floating):\n kind = 'f'\n else:\n # we could instead read this from the type string, but it's kind of\n # pandora's box, because there's also structured arrays, complex,\n # etc. For now, let's just restrict to numeric.\n raise RuntimeError(\"unexpected dtype\")\n dtype = np.promote_types(dtype, kind+size)\n\n arrays = tuple(np.require(arr, dtype=dtype, requirements=requirements)\n for arr in arrays)\n\n if len(arrays) > 1:\n return arrays\n else:\n return arrays[0]\n\n\n# Not a public function (yet)\ndef asintegerarrays(arrays, requirements=None, min_itemsize=None):\n \"\"\"Cast the given array(s) to the same integer type.\n\n Not a public function.\n\n This is useful when calling cython functions.\n\n Args:\n arrays (array-like): At least one array-like.\n\n requirements (str/list[str], optional): See :func:`numpy.require`.\n\n min_itemsize (int, optional):\n The minimum itemsize (in bytes) for the output arrays.\n\n Returns:\n Numpy array(s) satisfying the above requirements. They will all have\n the same dtype.\n\n \"\"\"\n # empty arrays are a problem because numy defaults them to float, so let's\n # do a tiny bit of prechecking\n arrays = [arr if len(arr) else np.asarray(arr, dtype=np.int8)\n for arr in arrays]\n\n if not arrays:\n raise TypeError('asintegerarrays() takes at least 1 array (0 given)')\n\n return _astypearrays(arrays, requirements, min_itemsize, [np.integer])\n\n\n# Not a public function (yet)\ndef asnumericarrays(arrays, requirements=None, min_itemsize=None):\n \"\"\"Cast the given array(s) to the same floating type.\n\n Not a public function.\n\n This is useful when calling cython functions.\n\n Args:\n *arrays (array-like): At least one array-like.\n\n requirements (str/list[str], optional): See :func:`numpy.require`.\n\n min_itemsize (int, optional):\n The minimum itemsize (in bytes) for the output arrays.\n\n Returns:\n Numpy array(s) satisfying the above requirements. They will all have\n the same dtype.\n\n \"\"\"\n if not arrays:\n raise TypeError('asnumericarrays() takes at least 1 array (0 given)')\n\n return _astypearrays(arrays, requirements, min_itemsize,\n [np.integer, np.floating])\n" ]	[ [ "numpy.log2", "numpy.asarray", "numpy.issubdtype", "numpy.promote_types", "numpy.require" ] ]
braedynl/DasCrazy	[ "02a3e41631929eaf402116d25299ec252f6fee2f" ]	[ "clean.py" ]	[ "import pandas as pd\n\nfrom util import load\n\n\ndef main(raw_filename: str, clean_filename: str) -> None:\n raw_data = load(raw_filename)\n clean_data = pd.DataFrame(columns=raw_data.columns)\n\n # First chat message to signal a \"das crazy\" moment\n indicator_row = None\n\n for _, row in raw_data.iterrows():\n\n message = row[\"message\"].lower()\n\n if \"crazy\" in message:\n\n # Filters other users messaging at (roughly) the same time, i.e., discards\n # all messages containing the word \"crazy\" within a 30 second interval\n\n # The user can alternatively be myself, as I will notate \"x2\" if there were\n # two back-to-back crazy moments (I've never witnessed more than two)\n if (\n (indicator_row is None)\n or (row[\"user\"] == \"braedynl_\" and \"x2\" in message)\n or (row[\"sent\"] - indicator_row[\"sent\"]).total_seconds() > 30\n ):\n indicator_row = row\n clean_data = clean_data.append(row, ignore_index=True)\n\n clean_data.to_csv(f\"data/{clean_filename}.csv\", index=False)\n\n\nif __name__ == \"__main__\":\n main(\"raw\", \"clean\")\n" ]	[ [ "pandas.DataFrame" ] ]
reic/groupLearning-Python-100-Days	[ "91746e6ee3acf2dbf0e9d324f6c6ce3cb91ed131" ]	[ "RE/grb2fig.py" ]	[ "import pandas as pd\nimport os\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport concurrent.futures\n\n\ndef grb_aggr(files, grb_xlsFileName):\n dft = []\n for file in files:\n dft.append(pd.read_excel(file))\n df = pd.concat(dft, ignore_index=True)\n # 輸出合併檔\n df.to_excel(grb_xlsFileName, index=False)\n return df\n\n\ndef year_fig(df, category, grb_figdata, figout=0):\n dft = pd.DataFrame(pd.pivot_table(df, index=category, values=[\n '本期經費(千元)'], aggfunc={'本期經費(千元)': [\"sum\", \"count\"]}).to_records())\n dft.rename(columns={\"('本期經費(千元)', 'count')\": \"件數\",\n \"('本期經費(千元)', 'sum')\": \"經費(千元)\"}, inplace=True)\n if isinstance(category, list):\n index_name = category[0]\n df2 = dft.pivot_table(index=index_name, columns=\"計畫年度\", values=[\n \"件數\", \"經費(千元)\"], fill_value=0)\n # df2.columns.name = None\n df2 = df2.reset_index()\n df2.to_excel(\n \"{}/{}_件數_經費.xlsx\".format(grb_figdata, category))\n df2.to_excel(\n \"{}/{}_件數_經費.xlsx\".format(grb_figdata, category))\n return\n dft.to_excel(\"{}/{}_件數_經費.xlsx\".format(grb_figdata, category), index=False)\n if figout:\n year_fig2(dft[category], dft[\"件數\"], category, \"件數\")\n year_fig2(dft[category], dft[\"經費(千元)\"], category, \"經費(千元)\")\n\n\ndef data_count(df, category):\n dft = pd.DataFrame(pd.pivot_table(df, index=category, values=[\n '本期經費(千元)'], aggfunc={'本期經費(千元)': [\"sum\", \"count\"]}).to_records())\n dft.rename(columns={\"('本期經費(千元)', 'count')\": \"件數\",\n \"('本期經費(千元)', 'sum')\": \"經費(千元)\"}, inplace=True)\n return dft\n\n\ndef year_fig2(xdata, ydata, xlab, ylab, grb_figdata):\n plt.rcParams['font.sans-serif'] = ['Microsoft JhengHei']\n plt.plot(xdata, ydata)\n plt.xlabel(xlab, fontsize=14)\n plt.ylabel(ylab, fontsize=14)\n plt.savefig(\"{}/{}_{}.png\".format(grb_figdata, xlab, ylab))\n plt.show()\n\n\ndef columnlinechart(writer, sheet_name, maxrow):\n workbook = writer.book\n worksheet = writer.sheets[sheet_name]\n # Create a chart object.\n chart = workbook.add_chart({'type': 'column'})\n\n # Configure the series of the chart from the dataframe data.\n chart.add_series({'name': f\"={sheet_name}!C1\", 'values': f\"={sheet_name}!$C$2:$C${maxrow}\",\n \"categories\": f\"={sheet_name}!$A$2:$A${maxrow}\",\n 'fill': {'color': '#808080'}, 'data_labels': {'value': True}, 'gap': 15})\n\n # 'type': 'column' 即為圖表類別為 line chart\n line_chart = workbook.add_chart({'type': 'line'})\n line_chart.add_series({'name': f\"={sheet_name}!B1\", \"categories\": f\"={sheet_name}!$A$2:$A${maxrow}\", 'values': f\"={sheet_name}!$B$2:$B${maxrow}\", 'data_labels': {'value': True, \"position\": \"above\"},\n 'y2_axis': True, \"marker\": {\"type\": \"circle\", \"size\": \"9\", \"fill\": {\"color\": \"white\"}}}) # 'y2_axis': 表示是否增加 secondary y-axis\n chart.combine(line_chart) # 將兩張圖 (bar chart & line chart) 組合在一起\n\n chart.set_legend({'position': 'top'}) # legend 位置於圖表下方\n chart.set_x_axis({'major_gridlines': {'visible': False}})\n chart.set_y_axis({'major_gridlines': {'visible': False}})\n # Turn off chart legend. It is on by default in Excel.\n # chart.set_legend({'position': 'none'})\n chart.set_size({'width': 800, 'height': 500})\n # Insert the chart into the worksheet.\n worksheet.insert_chart('F2', chart)\n\n\ndef barchart(writer, sheet_name, maxrow, maxcolumn):\n workbook = writer.book\n worksheet = writer.sheets[sheet_name]\n # Create a chart object.\n chart = workbook.add_chart({'type': 'bar', 'subtype': 'percent_stacked'})\n for itm in range(1, maxcolumn):\n colname = chr(65+itm)\n chart.add_series({\"name\": f\"='{sheet_name}'!${colname}$1\",\n 'categories': f\"='{sheet_name}'!$A$2:$A${maxrow}\",\n \"values\": f\"='{sheet_name}'!${colname}$2:${colname}${maxrow}\"\n })\n chart.set_legend({'position': 'top'}) # legend 位置於圖表下方\n chart.set_style(13)\n chart.set_y_axis({'major_gridlines': {'visible': False}})\n chart.set_x_axis({'major_gridlines': {'visible': False}})\n chart.set_size({'width': 800, 'height': 500})\n worksheet.insert_chart(\"F2\", chart)\n\n\ndef piechart(writer, sheet_name, maxrow):\n workbook = writer.book\n worksheet = writer.sheets[sheet_name]\n chart = workbook.add_chart({\"type\": \"pie\"})\n chart.add_series({'categories': f\"='{sheet_name}'!$A$2:$A${maxrow}\",\n \"values\": f\"='{sheet_name}'!$C$2:$C${maxrow}\",\n 'data_labels': {'category': True, 'percentage': True},\n })\n chart.set_legend({'position': 'left'}) # legend 位置於圖表下方\n chart.set_style(13)\n chart.set_size({'width': 800, 'height': 500})\n worksheet.insert_chart(\"F2\", chart)\n\n\ndef yeardiv(dfyears, period):\n # dfyears 為 df[\"year\"].values 的值\n years = list(set(dfyears))\n start = min(years)\n grouplabel = [f\"{itm}~{itm+period-1}\" for itm in years[::period]]\n groupyear = []\n for itm in dfyears:\n groupyear.append(grouplabel[(itm-start)//period])\n return groupyear\n\n\ndef checkdict(context, wordDict):\n if context in wordDict:\n wordDict[context] += 1\n else:\n wordDict[context] = 1\n\n\ndef main(grb_dir):\n print(grb_dir)\n grb_xlsFileName = f\"{grb_dir[:6]}_grb.xlsx\"\n outputfilename = f\"{grb_dir[:6]}_output.xlsx\"\n # 取得下載 xlsx 所有檔案名稱\n files = [\"{}/{}\".format(grb_dir, i) for i in os.listdir(grb_dir)]\n\n # 執行 xslx 合併檔案\n df = grb_aggr(files, grb_xlsFileName)\n # df = pd.read_excel(\"D:/grb.xlsx\")\n\n # 資料處理的工作\n # 僅取出國科會、科技部的計畫\n filterlist = [\"行政院國家科學委員會\", \"科技部\"]\n df1 = df[df[\"計畫主管機關\"].isin(filterlist)][['計畫中文名稱', '執行單位名稱', '計畫年度', '計畫主管機關', '研究性質', '研究領域', '本期期間(起)', '本期期間(訖)', '本期經費(千元)',\n '計畫主持人', '共同/協同主持人', '中文關鍵詞', '英文關鍵詞']]\n # 研究領域，僅取出第一個研究領域分析\n df1[\"主研究領域\"] = [itm[0] for itm in df1[\"研究領域\"].str.split(\";\").values]\n # 執行機構名稱的清理\n df1[\"執行單位_new\"] = [str(itm[1]).replace(\"台灣\", \"臺灣\") for itm in df1[\"執行單位名稱\"].str.extract(\n r'(國立\|.法人\|行政院)?(.大學\|.學院\|.研究院\|.學會\|.學校\|原子能委員會\|食品工業發展研究所\|國家同步輻射研究中心\|林業試驗所\|中醫藥研究所)').values]\n # 輸出整理過的檔案\n df1.to_excel(\"{}_整理.xlsx\".format(\n grb_xlsFileName[:grb_xlsFileName.rfind(\".\")]), index=False)\n\n with pd.ExcelWriter(outputfilename, engine='xlsxwriter') as writer:\n tmp = data_count(df1, \"計畫年度\")\n maxrow = len(tmp)+1\n tmp.to_excel(writer, sheet_name=\"計畫年度\", index=False)\n columnlinechart(writer, \"計畫年度\", maxrow)\n\n tmp = data_count(df, [\"研究性質\", \"計畫年度\"])\n mask = tmp[\"研究性質\"] == \"其他\"\n tmp[~mask].to_excel(writer, sheet_name=\"研究性質with年度\", index=False)\n\n tmp = data_count(df1, [\"研究性質\", \"計畫年度\"])\n mask = tmp[\"研究性質\"] == \"其他\"\n tmp = tmp[~mask]\n tmp.to_excel(writer, sheet_name=\"MOST 研究性質with年度\", index=False)\n for j in [4, 3, 2]:\n yearlen = len(set(tmp[\"計畫年度\"].values))\n if yearlen % j == 0:\n divdat = yearlen//j\n break\n\n groupyear = yeardiv(tmp[\"計畫年度\"].values, divdat)\n tmp[\"計畫年度\"] = groupyear\n tmp = pd.DataFrame(pd.pivot_table(tmp, index=\"研究性質\",\n values=\"經費(千元)\", columns=[\"計畫年度\"]).to_records())\n sindex = tmp.index.to_list()\n sindex[0] = 4\n tmp.index = sindex\n tmp.sort_index(inplace=True)\n tmp.to_excel(writer, sheet_name=\"MOST 研究性質 with 年度區間\", index=False)\n maxrow = len(tmp)+1\n maxcolumn = len(tmp.columns)\n barchart(writer, \"MOST 研究性質 with 年度區間\", maxrow, maxcolumn)\n\n tmp = data_count(df1, \"主研究領域\")\n tmp.sort_values(\"經費(千元)\", ascending=False, inplace=True)\n maxrow = len(tmp)+1\n tmp.to_excel(writer, \"主研究領域\", index=False)\n if maxrow > 13:\n maxrow = 13\n piechart(writer, \"主研究領域\", maxrow)\n\n sheetname = \"執行單位_new\"\n tmp = data_count(df1, sheetname)\n tmp.sort_values(\"經費(千元)\", ascending=False, inplace=True)\n maxrow = len(tmp)+1\n tmp.to_excel(writer, sheet_name=sheetname, index=False)\n if maxrow > 25:\n maxrow = 25\n piechart(writer, sheetname, maxrow)\n\n\nif __name__ == \"__main__\":\n # 定義區\n # 設定工作目錄\n working_dir = \"d:/tmp\"\n txt_data = \"txt\"\n os.chdir(working_dir)\n grb_dirs = [\"solarcell\", \"hydrogen\",\n \"storeenergy\", 'sysintegrate', 'windturbine']\n\n # # 做圖用的 xlsx 分檔的輸出位置\n grb_figdata = \"data2fig\"\n\n # # 建立 xlsx 輸出檔的存放目錄\n try:\n os.mkdir(txt_data)\n except FileExistsError:\n print(\"%s 的目標已存在\" % txt_data)\n\n try:\n os.mkdir(grb_figdata)\n except FileExistsError:\n print(\"%s 的目標已存在\" % grb_figdata)\n\n with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:\n executor.map(main, grb_dirs)\n" ]	[ [ "pandas.concat", "pandas.read_excel", "matplotlib.pyplot.plot", "pandas.ExcelWriter", "matplotlib.pyplot.xlabel", "pandas.pivot_table", "matplotlib.pyplot.show", "matplotlib.pyplot.ylabel" ] ]
HumHongeKamyaab/scipy	[ "ce61e02e912d15ea28b37ea036334b9ba266ebb5" ]	[ "scipy/special/tests/test_data.py" ]	[ "import os\n\nimport numpy as np\nfrom numpy import arccosh, arcsinh, arctanh\nfrom numpy.testing import suppress_warnings\nimport pytest\n\nfrom scipy.special import (\n lpn, lpmn, lpmv, lqn, lqmn, sph_harm, eval_legendre, eval_hermite,\n eval_laguerre, eval_genlaguerre, binom, cbrt, expm1, log1p, zeta,\n jn, jv, jvp, yn, yv, yvp, iv, ivp, kn, kv, kvp,\n gamma, gammaln, gammainc, gammaincc, gammaincinv, gammainccinv, digamma,\n beta, betainc, betaincinv, poch,\n ellipe, ellipeinc, ellipk, ellipkm1, ellipkinc, ellipj,\n elliprc, elliprd, elliprf, elliprg, elliprj,\n erf, erfc, erfinv, erfcinv, exp1, expi, expn,\n bdtrik, btdtr, btdtri, btdtria, btdtrib, chndtr, gdtr, gdtrc, gdtrix, gdtrib,\n nbdtrik, pdtrik, owens_t,\n mathieu_a, mathieu_b, mathieu_cem, mathieu_sem, mathieu_modcem1,\n mathieu_modsem1, mathieu_modcem2, mathieu_modsem2,\n ellip_harm, ellip_harm_2, spherical_jn, spherical_yn,\n)\nfrom scipy.integrate import IntegrationWarning\n\nfrom scipy.special._testutils import FuncData\n\nDATASETS_BOOST = np.load(os.path.join(os.path.dirname(__file__),\n \"data\", \"boost.npz\"))\n\nDATASETS_GSL = np.load(os.path.join(os.path.dirname(__file__),\n \"data\", \"gsl.npz\"))\n\nDATASETS_LOCAL = np.load(os.path.join(os.path.dirname(__file__),\n \"data\", \"local.npz\"))\n\n\ndef data(func, dataname, a, kw):\n kw.setdefault('dataname', dataname)\n return FuncData(func, DATASETS_BOOST[dataname], a, *kw)\n\n\ndef data_gsl(func, dataname, a, *kw):\n kw.setdefault('dataname', dataname)\n return FuncData(func, DATASETS_GSL[dataname], a, *kw)\n\n\ndef data_local(func, dataname, a, *kw):\n kw.setdefault('dataname', dataname)\n return FuncData(func, DATASETS_LOCAL[dataname], a, *kw)\n\n\ndef ellipk_(k):\n return ellipk(kk)\n\n\ndef ellipkinc_(f, k):\n return ellipkinc(f, kk)\n\n\ndef ellipe_(k):\n return ellipe(kk)\n\n\ndef ellipeinc_(f, k):\n return ellipeinc(f, kk)\n\n\ndef ellipj_(k):\n return ellipj(kk)\n\n\ndef zeta_(x):\n return zeta(x, 1.)\n\n\ndef assoc_legendre_p_boost_(nu, mu, x):\n # the boost test data is for integer orders only\n return lpmv(mu, nu.astype(int), x)\n\ndef legendre_p_via_assoc_(nu, x):\n return lpmv(0, nu, x)\n\ndef lpn_(n, x):\n return lpn(n.astype('l'), x)[0][-1]\n\ndef lqn_(n, x):\n return lqn(n.astype('l'), x)[0][-1]\n\ndef legendre_p_via_lpmn(n, x):\n return lpmn(0, n, x)[0][0,-1]\n\ndef legendre_q_via_lqmn(n, x):\n return lqmn(0, n, x)[0][0,-1]\n\ndef mathieu_ce_rad(m, q, x):\n return mathieu_cem(m, q, x180/np.pi)[0]\n\n\ndef mathieu_se_rad(m, q, x):\n return mathieu_sem(m, q, x180/np.pi)[0]\n\n\ndef mathieu_mc1_scaled(m, q, x):\n # GSL follows a different normalization.\n # We follow Abramowitz & Stegun, they apparently something else.\n return mathieu_modcem1(m, q, x)[0] * np.sqrt(np.pi/2)\n\n\ndef mathieu_ms1_scaled(m, q, x):\n return mathieu_modsem1(m, q, x)[0] * np.sqrt(np.pi/2)\n\n\ndef mathieu_mc2_scaled(m, q, x):\n return mathieu_modcem2(m, q, x)[0] * np.sqrt(np.pi/2)\n\n\ndef mathieu_ms2_scaled(m, q, x):\n return mathieu_modsem2(m, q, x)[0] * np.sqrt(np.pi/2)\n\ndef eval_legendre_ld(n, x):\n return eval_legendre(n.astype('l'), x)\n\ndef eval_legendre_dd(n, x):\n return eval_legendre(n.astype('d'), x)\n\ndef eval_hermite_ld(n, x):\n return eval_hermite(n.astype('l'), x)\n\ndef eval_laguerre_ld(n, x):\n return eval_laguerre(n.astype('l'), x)\n\ndef eval_laguerre_dd(n, x):\n return eval_laguerre(n.astype('d'), x)\n\ndef eval_genlaguerre_ldd(n, a, x):\n return eval_genlaguerre(n.astype('l'), a, x)\n\ndef eval_genlaguerre_ddd(n, a, x):\n return eval_genlaguerre(n.astype('d'), a, x)\n\ndef bdtrik_comp(y, n, p):\n return bdtrik(1-y, n, p)\n\ndef btdtri_comp(a, b, p):\n return btdtri(a, b, 1-p)\n\ndef btdtria_comp(p, b, x):\n return btdtria(1-p, b, x)\n\ndef btdtrib_comp(a, p, x):\n return btdtrib(a, 1-p, x)\n\ndef gdtr_(p, x):\n return gdtr(1.0, p, x)\n\ndef gdtrc_(p, x):\n return gdtrc(1.0, p, x)\n\ndef gdtrix_(b, p):\n return gdtrix(1.0, b, p)\n\ndef gdtrix_comp(b, p):\n return gdtrix(1.0, b, 1-p)\n\ndef gdtrib_(p, x):\n return gdtrib(1.0, p, x)\n\ndef gdtrib_comp(p, x):\n return gdtrib(1.0, 1-p, x)\n\ndef nbdtrik_comp(y, n, p):\n return nbdtrik(1-y, n, p)\n\ndef pdtrik_comp(p, m):\n return pdtrik(1-p, m)\n\ndef poch_(z, m):\n return 1.0 / poch(z, m)\n\ndef poch_minus(z, m):\n return 1.0 / poch(z, -m)\n\ndef spherical_jn_(n, x):\n return spherical_jn(n.astype('l'), x)\n\ndef spherical_yn_(n, x):\n return spherical_yn(n.astype('l'), x)\n\ndef sph_harm_(m, n, theta, phi):\n y = sph_harm(m, n, theta, phi)\n return (y.real, y.imag)\n\ndef cexpm1(x, y):\n z = expm1(x + 1jy)\n return z.real, z.imag\n\ndef clog1p(x, y):\n z = log1p(x + 1jy)\n return z.real, z.imag\n\n\nBOOST_TESTS = [\n data(arccosh, 'acosh_data_ipp-acosh_data', 0, 1, rtol=5e-13),\n data(arccosh, 'acosh_data_ipp-acosh_data', 0j, 1, rtol=5e-13),\n\n data(arcsinh, 'asinh_data_ipp-asinh_data', 0, 1, rtol=1e-11),\n data(arcsinh, 'asinh_data_ipp-asinh_data', 0j, 1, rtol=1e-11),\n\n data(arctanh, 'atanh_data_ipp-atanh_data', 0, 1, rtol=1e-11),\n data(arctanh, 'atanh_data_ipp-atanh_data', 0j, 1, rtol=1e-11),\n\n data(assoc_legendre_p_boost_, 'assoc_legendre_p_ipp-assoc_legendre_p', (0,1,2), 3, rtol=1e-11),\n\n data(legendre_p_via_assoc_, 'legendre_p_ipp-legendre_p', (0,1), 2, rtol=1e-11),\n data(legendre_p_via_assoc_, 'legendre_p_large_ipp-legendre_p_large', (0,1), 2, rtol=9.6e-14),\n data(legendre_p_via_lpmn, 'legendre_p_ipp-legendre_p', (0,1), 2, rtol=5e-14, vectorized=False),\n data(legendre_p_via_lpmn, 'legendre_p_large_ipp-legendre_p_large', (0,1), 2, rtol=9.6e-14, vectorized=False),\n data(lpn_, 'legendre_p_ipp-legendre_p', (0,1), 2, rtol=5e-14, vectorized=False),\n data(lpn_, 'legendre_p_large_ipp-legendre_p_large', (0,1), 2, rtol=3e-13, vectorized=False),\n data(eval_legendre_ld, 'legendre_p_ipp-legendre_p', (0,1), 2, rtol=6e-14),\n data(eval_legendre_ld, 'legendre_p_large_ipp-legendre_p_large', (0,1), 2, rtol=2e-13),\n data(eval_legendre_dd, 'legendre_p_ipp-legendre_p', (0,1), 2, rtol=2e-14),\n data(eval_legendre_dd, 'legendre_p_large_ipp-legendre_p_large', (0,1), 2, rtol=2e-13),\n\n data(lqn_, 'legendre_p_ipp-legendre_p', (0,1), 3, rtol=2e-14, vectorized=False),\n data(lqn_, 'legendre_p_large_ipp-legendre_p_large', (0,1), 3, rtol=2e-12, vectorized=False),\n data(legendre_q_via_lqmn, 'legendre_p_ipp-legendre_p', (0,1), 3, rtol=2e-14, vectorized=False),\n data(legendre_q_via_lqmn, 'legendre_p_large_ipp-legendre_p_large', (0,1), 3, rtol=2e-12, vectorized=False),\n\n data(beta, 'beta_exp_data_ipp-beta_exp_data', (0,1), 2, rtol=1e-13),\n data(beta, 'beta_exp_data_ipp-beta_exp_data', (0,1), 2, rtol=1e-13),\n data(beta, 'beta_med_data_ipp-beta_med_data', (0,1), 2, rtol=5e-13),\n\n data(betainc, 'ibeta_small_data_ipp-ibeta_small_data', (0,1,2), 5, rtol=6e-15),\n data(betainc, 'ibeta_data_ipp-ibeta_data', (0,1,2), 5, rtol=5e-13),\n data(betainc, 'ibeta_int_data_ipp-ibeta_int_data', (0,1,2), 5, rtol=2e-14),\n data(betainc, 'ibeta_large_data_ipp-ibeta_large_data', (0,1,2), 5, rtol=4e-10),\n\n data(betaincinv, 'ibeta_inv_data_ipp-ibeta_inv_data', (0,1,2), 3, rtol=1e-5),\n\n data(btdtr, 'ibeta_small_data_ipp-ibeta_small_data', (0,1,2), 5, rtol=6e-15),\n data(btdtr, 'ibeta_data_ipp-ibeta_data', (0,1,2), 5, rtol=4e-13),\n data(btdtr, 'ibeta_int_data_ipp-ibeta_int_data', (0,1,2), 5, rtol=2e-14),\n data(btdtr, 'ibeta_large_data_ipp-ibeta_large_data', (0,1,2), 5, rtol=4e-10),\n\n data(btdtri, 'ibeta_inv_data_ipp-ibeta_inv_data', (0,1,2), 3, rtol=1e-5),\n data(btdtri_comp, 'ibeta_inv_data_ipp-ibeta_inv_data', (0,1,2), 4, rtol=8e-7),\n\n data(btdtria, 'ibeta_inva_data_ipp-ibeta_inva_data', (2,0,1), 3, rtol=5e-9),\n data(btdtria_comp, 'ibeta_inva_data_ipp-ibeta_inva_data', (2,0,1), 4, rtol=5e-9),\n\n data(btdtrib, 'ibeta_inva_data_ipp-ibeta_inva_data', (0,2,1), 5, rtol=5e-9),\n data(btdtrib_comp, 'ibeta_inva_data_ipp-ibeta_inva_data', (0,2,1), 6, rtol=5e-9),\n\n data(binom, 'binomial_data_ipp-binomial_data', (0,1), 2, rtol=1e-13),\n data(binom, 'binomial_large_data_ipp-binomial_large_data', (0,1), 2, rtol=5e-13),\n\n data(bdtrik, 'binomial_quantile_ipp-binomial_quantile_data', (2,0,1), 3, rtol=5e-9),\n data(bdtrik_comp, 'binomial_quantile_ipp-binomial_quantile_data', (2,0,1), 4, rtol=5e-9),\n\n data(nbdtrik, 'negative_binomial_quantile_ipp-negative_binomial_quantile_data', (2,0,1), 3, rtol=4e-9),\n data(nbdtrik_comp, 'negative_binomial_quantile_ipp-negative_binomial_quantile_data', (2,0,1), 4, rtol=4e-9),\n\n data(pdtrik, 'poisson_quantile_ipp-poisson_quantile_data', (1,0), 2, rtol=3e-9),\n data(pdtrik_comp, 'poisson_quantile_ipp-poisson_quantile_data', (1,0), 3, rtol=4e-9),\n\n data(cbrt, 'cbrt_data_ipp-cbrt_data', 1, 0),\n\n data(digamma, 'digamma_data_ipp-digamma_data', 0, 1),\n data(digamma, 'digamma_data_ipp-digamma_data', 0j, 1),\n data(digamma, 'digamma_neg_data_ipp-digamma_neg_data', 0, 1, rtol=2e-13),\n data(digamma, 'digamma_neg_data_ipp-digamma_neg_data', 0j, 1, rtol=1e-13),\n data(digamma, 'digamma_root_data_ipp-digamma_root_data', 0, 1, rtol=1e-15),\n data(digamma, 'digamma_root_data_ipp-digamma_root_data', 0j, 1, rtol=1e-15),\n data(digamma, 'digamma_small_data_ipp-digamma_small_data', 0, 1, rtol=1e-15),\n data(digamma, 'digamma_small_data_ipp-digamma_small_data', 0j, 1, rtol=1e-14),\n\n data(ellipk_, 'ellint_k_data_ipp-ellint_k_data', 0, 1),\n data(ellipkinc_, 'ellint_f_data_ipp-ellint_f_data', (0,1), 2, rtol=1e-14),\n data(ellipe_, 'ellint_e_data_ipp-ellint_e_data', 0, 1),\n data(ellipeinc_, 'ellint_e2_data_ipp-ellint_e2_data', (0,1), 2, rtol=1e-14),\n\n data(erf, 'erf_data_ipp-erf_data', 0, 1),\n data(erf, 'erf_data_ipp-erf_data', 0j, 1, rtol=1e-13),\n data(erfc, 'erf_data_ipp-erf_data', 0, 2, rtol=6e-15),\n data(erf, 'erf_large_data_ipp-erf_large_data', 0, 1),\n data(erf, 'erf_large_data_ipp-erf_large_data', 0j, 1),\n data(erfc, 'erf_large_data_ipp-erf_large_data', 0, 2, rtol=4e-14),\n data(erf, 'erf_small_data_ipp-erf_small_data', 0, 1),\n data(erf, 'erf_small_data_ipp-erf_small_data', 0j, 1, rtol=1e-13),\n data(erfc, 'erf_small_data_ipp-erf_small_data', 0, 2),\n\n data(erfinv, 'erf_inv_data_ipp-erf_inv_data', 0, 1),\n data(erfcinv, 'erfc_inv_data_ipp-erfc_inv_data', 0, 1),\n data(erfcinv, 'erfc_inv_big_data_ipp-erfc_inv_big_data', 0, 1, param_filter=(lambda s: s > 0)),\n\n data(exp1, 'expint_1_data_ipp-expint_1_data', 1, 2, rtol=1e-13),\n data(exp1, 'expint_1_data_ipp-expint_1_data', 1j, 2, rtol=5e-9),\n data(expi, 'expinti_data_ipp-expinti_data', 0, 1, rtol=1e-13),\n data(expi, 'expinti_data_double_ipp-expinti_data_double', 0, 1, rtol=1e-13),\n data(expi, 'expinti_data_long_ipp-expinti_data_long', 0, 1),\n\n data(expn, 'expint_small_data_ipp-expint_small_data', (0,1), 2),\n data(expn, 'expint_data_ipp-expint_data', (0,1), 2, rtol=1e-14),\n\n data(gamma, 'test_gamma_data_ipp-near_0', 0, 1),\n data(gamma, 'test_gamma_data_ipp-near_1', 0, 1),\n data(gamma, 'test_gamma_data_ipp-near_2', 0, 1),\n data(gamma, 'test_gamma_data_ipp-near_m10', 0, 1),\n data(gamma, 'test_gamma_data_ipp-near_m55', 0, 1, rtol=7e-12),\n data(gamma, 'test_gamma_data_ipp-factorials', 0, 1, rtol=4e-14),\n data(gamma, 'test_gamma_data_ipp-near_0', 0j, 1, rtol=2e-9),\n data(gamma, 'test_gamma_data_ipp-near_1', 0j, 1, rtol=2e-9),\n data(gamma, 'test_gamma_data_ipp-near_2', 0j, 1, rtol=2e-9),\n data(gamma, 'test_gamma_data_ipp-near_m10', 0j, 1, rtol=2e-9),\n data(gamma, 'test_gamma_data_ipp-near_m55', 0j, 1, rtol=2e-9),\n data(gamma, 'test_gamma_data_ipp-factorials', 0j, 1, rtol=2e-13),\n data(gammaln, 'test_gamma_data_ipp-near_0', 0, 2, rtol=5e-11),\n data(gammaln, 'test_gamma_data_ipp-near_1', 0, 2, rtol=5e-11),\n data(gammaln, 'test_gamma_data_ipp-near_2', 0, 2, rtol=2e-10),\n data(gammaln, 'test_gamma_data_ipp-near_m10', 0, 2, rtol=5e-11),\n data(gammaln, 'test_gamma_data_ipp-near_m55', 0, 2, rtol=5e-11),\n data(gammaln, 'test_gamma_data_ipp-factorials', 0, 2),\n\n data(gammainc, 'igamma_small_data_ipp-igamma_small_data', (0,1), 5, rtol=5e-15),\n data(gammainc, 'igamma_med_data_ipp-igamma_med_data', (0,1), 5, rtol=2e-13),\n data(gammainc, 'igamma_int_data_ipp-igamma_int_data', (0,1), 5, rtol=2e-13),\n data(gammainc, 'igamma_big_data_ipp-igamma_big_data', (0,1), 5, rtol=1e-12),\n\n data(gdtr_, 'igamma_small_data_ipp-igamma_small_data', (0,1), 5, rtol=1e-13),\n data(gdtr_, 'igamma_med_data_ipp-igamma_med_data', (0,1), 5, rtol=2e-13),\n data(gdtr_, 'igamma_int_data_ipp-igamma_int_data', (0,1), 5, rtol=2e-13),\n data(gdtr_, 'igamma_big_data_ipp-igamma_big_data', (0,1), 5, rtol=2e-9),\n\n data(gammaincc, 'igamma_small_data_ipp-igamma_small_data', (0,1), 3, rtol=1e-13),\n data(gammaincc, 'igamma_med_data_ipp-igamma_med_data', (0,1), 3, rtol=2e-13),\n data(gammaincc, 'igamma_int_data_ipp-igamma_int_data', (0,1), 3, rtol=4e-14),\n data(gammaincc, 'igamma_big_data_ipp-igamma_big_data', (0,1), 3, rtol=1e-11),\n\n data(gdtrc_, 'igamma_small_data_ipp-igamma_small_data', (0,1), 3, rtol=1e-13),\n data(gdtrc_, 'igamma_med_data_ipp-igamma_med_data', (0,1), 3, rtol=2e-13),\n data(gdtrc_, 'igamma_int_data_ipp-igamma_int_data', (0,1), 3, rtol=4e-14),\n data(gdtrc_, 'igamma_big_data_ipp-igamma_big_data', (0,1), 3, rtol=1e-11),\n\n data(gdtrib_, 'igamma_inva_data_ipp-igamma_inva_data', (1,0), 2, rtol=5e-9),\n data(gdtrib_comp, 'igamma_inva_data_ipp-igamma_inva_data', (1,0), 3, rtol=5e-9),\n\n data(poch_, 'tgamma_delta_ratio_data_ipp-tgamma_delta_ratio_data', (0,1), 2, rtol=2e-13),\n data(poch_, 'tgamma_delta_ratio_int_ipp-tgamma_delta_ratio_int', (0,1), 2,),\n data(poch_, 'tgamma_delta_ratio_int2_ipp-tgamma_delta_ratio_int2', (0,1), 2,),\n data(poch_minus, 'tgamma_delta_ratio_data_ipp-tgamma_delta_ratio_data', (0,1), 3, rtol=2e-13),\n data(poch_minus, 'tgamma_delta_ratio_int_ipp-tgamma_delta_ratio_int', (0,1), 3),\n data(poch_minus, 'tgamma_delta_ratio_int2_ipp-tgamma_delta_ratio_int2', (0,1), 3),\n\n data(eval_hermite_ld, 'hermite_ipp-hermite', (0,1), 2, rtol=2e-14),\n\n data(eval_laguerre_ld, 'laguerre2_ipp-laguerre2', (0,1), 2, rtol=7e-12),\n data(eval_laguerre_dd, 'laguerre2_ipp-laguerre2', (0,1), 2, knownfailure='hyp2f1 insufficiently accurate.'),\n data(eval_genlaguerre_ldd, 'laguerre3_ipp-laguerre3', (0,1,2), 3, rtol=2e-13),\n data(eval_genlaguerre_ddd, 'laguerre3_ipp-laguerre3', (0,1,2), 3, knownfailure='hyp2f1 insufficiently accurate.'),\n\n data(log1p, 'log1p_expm1_data_ipp-log1p_expm1_data', 0, 1),\n data(expm1, 'log1p_expm1_data_ipp-log1p_expm1_data', 0, 2),\n\n data(iv, 'bessel_i_data_ipp-bessel_i_data', (0,1), 2, rtol=1e-12),\n data(iv, 'bessel_i_data_ipp-bessel_i_data', (0,1j), 2, rtol=2e-10, atol=1e-306),\n data(iv, 'bessel_i_int_data_ipp-bessel_i_int_data', (0,1), 2, rtol=1e-9),\n data(iv, 'bessel_i_int_data_ipp-bessel_i_int_data', (0,1j), 2, rtol=2e-10),\n\n data(ivp, 'bessel_i_prime_int_data_ipp-bessel_i_prime_int_data', (0,1), 2, rtol=1.2e-13),\n data(ivp, 'bessel_i_prime_int_data_ipp-bessel_i_prime_int_data', (0,1j), 2, rtol=1.2e-13, atol=1e-300),\n\n data(jn, 'bessel_j_int_data_ipp-bessel_j_int_data', (0,1), 2, rtol=1e-12),\n data(jn, 'bessel_j_int_data_ipp-bessel_j_int_data', (0,1j), 2, rtol=1e-12),\n data(jn, 'bessel_j_large_data_ipp-bessel_j_large_data', (0,1), 2, rtol=6e-11),\n data(jn, 'bessel_j_large_data_ipp-bessel_j_large_data', (0,1j), 2, rtol=6e-11),\n\n data(jv, 'bessel_j_int_data_ipp-bessel_j_int_data', (0,1), 2, rtol=1e-12),\n data(jv, 'bessel_j_int_data_ipp-bessel_j_int_data', (0,1j), 2, rtol=1e-12),\n data(jv, 'bessel_j_data_ipp-bessel_j_data', (0,1), 2, rtol=1e-12),\n data(jv, 'bessel_j_data_ipp-bessel_j_data', (0,1j), 2, rtol=1e-12),\n\n data(jvp, 'bessel_j_prime_int_data_ipp-bessel_j_prime_int_data', (0,1), 2, rtol=1e-13),\n data(jvp, 'bessel_j_prime_int_data_ipp-bessel_j_prime_int_data', (0,1j), 2, rtol=1e-13),\n data(jvp, 'bessel_j_prime_large_data_ipp-bessel_j_prime_large_data', (0,1), 2, rtol=1e-11),\n data(jvp, 'bessel_j_prime_large_data_ipp-bessel_j_prime_large_data', (0,1j), 2, rtol=1e-11),\n\n data(kn, 'bessel_k_int_data_ipp-bessel_k_int_data', (0,1), 2, rtol=1e-12),\n\n data(kv, 'bessel_k_int_data_ipp-bessel_k_int_data', (0,1), 2, rtol=1e-12),\n data(kv, 'bessel_k_int_data_ipp-bessel_k_int_data', (0,1j), 2, rtol=1e-12),\n data(kv, 'bessel_k_data_ipp-bessel_k_data', (0,1), 2, rtol=1e-12),\n data(kv, 'bessel_k_data_ipp-bessel_k_data', (0,1j), 2, rtol=1e-12),\n\n data(kvp, 'bessel_k_prime_int_data_ipp-bessel_k_prime_int_data', (0,1), 2, rtol=3e-14),\n data(kvp, 'bessel_k_prime_int_data_ipp-bessel_k_prime_int_data', (0,1j), 2, rtol=3e-14),\n data(kvp, 'bessel_k_prime_data_ipp-bessel_k_prime_data', (0,1), 2, rtol=7e-14),\n data(kvp, 'bessel_k_prime_data_ipp-bessel_k_prime_data', (0,1j), 2, rtol=7e-14),\n\n data(yn, 'bessel_y01_data_ipp-bessel_y01_data', (0,1), 2, rtol=1e-12),\n data(yn, 'bessel_yn_data_ipp-bessel_yn_data', (0,1), 2, rtol=1e-12),\n\n data(yv, 'bessel_yn_data_ipp-bessel_yn_data', (0,1), 2, rtol=1e-12),\n data(yv, 'bessel_yn_data_ipp-bessel_yn_data', (0,1j), 2, rtol=1e-12),\n data(yv, 'bessel_yv_data_ipp-bessel_yv_data', (0,1), 2, rtol=1e-10),\n data(yv, 'bessel_yv_data_ipp-bessel_yv_data', (0,1j), 2, rtol=1e-10),\n\n data(yvp, 'bessel_yv_prime_data_ipp-bessel_yv_prime_data', (0, 1), 2, rtol=4e-9),\n data(yvp, 'bessel_yv_prime_data_ipp-bessel_yv_prime_data', (0, 1j), 2, rtol=4e-9),\n\n data(zeta_, 'zeta_data_ipp-zeta_data', 0, 1, param_filter=(lambda s: s > 1)),\n data(zeta_, 'zeta_neg_data_ipp-zeta_neg_data', 0, 1, param_filter=(lambda s: s > 1)),\n data(zeta_, 'zeta_1_up_data_ipp-zeta_1_up_data', 0, 1, param_filter=(lambda s: s > 1)),\n data(zeta_, 'zeta_1_below_data_ipp-zeta_1_below_data', 0, 1, param_filter=(lambda s: s > 1)),\n\n data(gammaincinv, 'gamma_inv_small_data_ipp-gamma_inv_small_data', (0,1), 2, rtol=1e-11),\n data(gammaincinv, 'gamma_inv_data_ipp-gamma_inv_data', (0,1), 2, rtol=1e-14),\n data(gammaincinv, 'gamma_inv_big_data_ipp-gamma_inv_big_data', (0,1), 2, rtol=1e-11),\n\n data(gammainccinv, 'gamma_inv_small_data_ipp-gamma_inv_small_data', (0,1), 3, rtol=1e-12),\n data(gammainccinv, 'gamma_inv_data_ipp-gamma_inv_data', (0,1), 3, rtol=1e-14),\n data(gammainccinv, 'gamma_inv_big_data_ipp-gamma_inv_big_data', (0,1), 3, rtol=1e-14),\n\n data(gdtrix_, 'gamma_inv_small_data_ipp-gamma_inv_small_data', (0,1), 2, rtol=3e-13, knownfailure='gdtrix unflow some points'),\n data(gdtrix_, 'gamma_inv_data_ipp-gamma_inv_data', (0,1), 2, rtol=3e-15),\n data(gdtrix_, 'gamma_inv_big_data_ipp-gamma_inv_big_data', (0,1), 2),\n data(gdtrix_comp, 'gamma_inv_small_data_ipp-gamma_inv_small_data', (0,1), 2, knownfailure='gdtrix bad some points'),\n data(gdtrix_comp, 'gamma_inv_data_ipp-gamma_inv_data', (0,1), 3, rtol=6e-15),\n data(gdtrix_comp, 'gamma_inv_big_data_ipp-gamma_inv_big_data', (0,1), 3),\n\n data(chndtr, 'nccs_ipp-nccs', (2,0,1), 3, rtol=3e-5),\n data(chndtr, 'nccs_big_ipp-nccs_big', (2,0,1), 3, rtol=5e-4, knownfailure='chndtr inaccurate some points'),\n\n data(sph_harm_, 'spherical_harmonic_ipp-spherical_harmonic', (1,0,3,2), (4,5), rtol=5e-11,\n param_filter=(lambda p: np.ones(p.shape, '?'),\n lambda p: np.ones(p.shape, '?'),\n lambda p: np.logical_and(p < 2*np.pi, p >= 0),\n lambda p: np.logical_and(p < np.pi, p >= 0))),\n\n data(spherical_jn_, 'sph_bessel_data_ipp-sph_bessel_data', (0,1), 2, rtol=1e-13),\n data(spherical_yn_, 'sph_neumann_data_ipp-sph_neumann_data', (0,1), 2, rtol=8e-15),\n\n data(owens_t, 'owens_t_ipp-owens_t', (0, 1), 2, rtol=5e-14),\n data(owens_t, 'owens_t_large_data_ipp-owens_t_large_data', (0, 1), 2, rtol=8e-12),\n\n # -- test data exists in boost but is not used in scipy --\n\n # ibeta_derivative_data_ipp/ibeta_derivative_data.txt\n # ibeta_derivative_int_data_ipp/ibeta_derivative_int_data.txt\n # ibeta_derivative_large_data_ipp/ibeta_derivative_large_data.txt\n # ibeta_derivative_small_data_ipp/ibeta_derivative_small_data.txt\n\n # bessel_y01_prime_data_ipp/bessel_y01_prime_data.txt\n # bessel_yn_prime_data_ipp/bessel_yn_prime_data.txt\n # sph_bessel_prime_data_ipp/sph_bessel_prime_data.txt\n # sph_neumann_prime_data_ipp/sph_neumann_prime_data.txt\n\n # ellint_d2_data_ipp/ellint_d2_data.txt\n # ellint_d_data_ipp/ellint_d_data.txt\n # ellint_pi2_data_ipp/ellint_pi2_data.txt\n # ellint_pi3_data_ipp/ellint_pi3_data.txt\n # ellint_pi3_large_data_ipp/ellint_pi3_large_data.txt\n data(elliprc, 'ellint_rc_data_ipp-ellint_rc_data', (0, 1), 2,\n rtol=5e-16),\n data(elliprd, 'ellint_rd_data_ipp-ellint_rd_data', (0, 1, 2), 3,\n rtol=5e-16),\n data(elliprd, 'ellint_rd_0xy_ipp-ellint_rd_0xy', (0, 1, 2), 3,\n rtol=5e-16),\n data(elliprd, 'ellint_rd_0yy_ipp-ellint_rd_0yy', (0, 1, 2), 3,\n rtol=5e-16),\n data(elliprd, 'ellint_rd_xxx_ipp-ellint_rd_xxx', (0, 1, 2), 3,\n rtol=5e-16),\n # Some of the following rtol for elliprd may be larger than 5e-16 to\n # work around some hard cases in the Boost test where we get slightly\n # larger error than the ideal bound when the x (==y) input is close to\n # zero.\n # Also the accuracy on 32-bit buids with g++ may suffer from excess\n # loss of precision; see GCC bugzilla 323\n # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=323\n data(elliprd, 'ellint_rd_xxz_ipp-ellint_rd_xxz', (0, 1, 2), 3,\n rtol=6.5e-16),\n data(elliprd, 'ellint_rd_xyy_ipp-ellint_rd_xyy', (0, 1, 2), 3,\n rtol=6e-16),\n data(elliprf, 'ellint_rf_data_ipp-ellint_rf_data', (0, 1, 2), 3,\n rtol=5e-16),\n data(elliprf, 'ellint_rf_xxx_ipp-ellint_rf_xxx', (0, 1, 2), 3,\n rtol=5e-16),\n data(elliprf, 'ellint_rf_xyy_ipp-ellint_rf_xyy', (0, 1, 2), 3,\n rtol=5e-16),\n data(elliprf, 'ellint_rf_xy0_ipp-ellint_rf_xy0', (0, 1, 2), 3,\n rtol=5e-16),\n data(elliprf, 'ellint_rf_0yy_ipp-ellint_rf_0yy', (0, 1, 2), 3,\n rtol=5e-16),\n # The accuracy of R_G is primarily limited by R_D that is used\n # internally. It is generally worse than R_D. Notice that we increased\n # the rtol for R_G here. The cases with duplicate arguments are\n # slightly less likely to be unbalanced (at least two arguments are\n # already balanced) so the error bound is slightly better. Again,\n # precision with g++ 32-bit is even worse.\n data(elliprg, 'ellint_rg_ipp-ellint_rg', (0, 1, 2), 3,\n rtol=8.0e-16),\n data(elliprg, 'ellint_rg_xxx_ipp-ellint_rg_xxx', (0, 1, 2), 3,\n rtol=6e-16),\n data(elliprg, 'ellint_rg_xyy_ipp-ellint_rg_xyy', (0, 1, 2), 3,\n rtol=7.5e-16),\n data(elliprg, 'ellint_rg_xy0_ipp-ellint_rg_xy0', (0, 1, 2), 3,\n rtol=5e-16),\n data(elliprg, 'ellint_rg_00x_ipp-ellint_rg_00x', (0, 1, 2), 3,\n rtol=5e-16),\n data(elliprj, 'ellint_rj_data_ipp-ellint_rj_data', (0, 1, 2, 3), 4,\n rtol=5e-16, atol=1e-25,\n param_filter=(lambda s: s <= 5e-26,)),\n # ellint_rc_data_ipp/ellint_rc_data.txt\n # ellint_rd_0xy_ipp/ellint_rd_0xy.txt\n # ellint_rd_0yy_ipp/ellint_rd_0yy.txt\n # ellint_rd_data_ipp/ellint_rd_data.txt\n # ellint_rd_xxx_ipp/ellint_rd_xxx.txt\n # ellint_rd_xxz_ipp/ellint_rd_xxz.txt\n # ellint_rd_xyy_ipp/ellint_rd_xyy.txt\n # ellint_rf_0yy_ipp/ellint_rf_0yy.txt\n # ellint_rf_data_ipp/ellint_rf_data.txt\n # ellint_rf_xxx_ipp/ellint_rf_xxx.txt\n # ellint_rf_xy0_ipp/ellint_rf_xy0.txt\n # ellint_rf_xyy_ipp/ellint_rf_xyy.txt\n # ellint_rg_00x_ipp/ellint_rg_00x.txt\n # ellint_rg_ipp/ellint_rg.txt\n # ellint_rg_xxx_ipp/ellint_rg_xxx.txt\n # ellint_rg_xy0_ipp/ellint_rg_xy0.txt\n # ellint_rg_xyy_ipp/ellint_rg_xyy.txt\n # ellint_rj_data_ipp/ellint_rj_data.txt\n # ellint_rj_e2_ipp/ellint_rj_e2.txt\n # ellint_rj_e3_ipp/ellint_rj_e3.txt\n # ellint_rj_e4_ipp/ellint_rj_e4.txt\n # ellint_rj_zp_ipp/ellint_rj_zp.txt\n\n # jacobi_elliptic_ipp/jacobi_elliptic.txt\n # jacobi_elliptic_small_ipp/jacobi_elliptic_small.txt\n # jacobi_large_phi_ipp/jacobi_large_phi.txt\n # jacobi_near_1_ipp/jacobi_near_1.txt\n # jacobi_zeta_big_phi_ipp/jacobi_zeta_big_phi.txt\n # jacobi_zeta_data_ipp/jacobi_zeta_data.txt\n\n # heuman_lambda_data_ipp/heuman_lambda_data.txt\n\n # hypergeometric_0F2_ipp/hypergeometric_0F2.txt\n # hypergeometric_1F1_big_ipp/hypergeometric_1F1_big.txt\n # hypergeometric_1F1_ipp/hypergeometric_1F1.txt\n # hypergeometric_1F1_small_random_ipp/hypergeometric_1F1_small_random.txt\n # hypergeometric_1F2_ipp/hypergeometric_1F2.txt\n # hypergeometric_1f1_large_regularized_ipp/hypergeometric_1f1_large_regularized.txt\n # hypergeometric_1f1_log_large_unsolved_ipp/hypergeometric_1f1_log_large_unsolved.txt\n # hypergeometric_2F0_half_ipp/hypergeometric_2F0_half.txt\n # hypergeometric_2F0_integer_a2_ipp/hypergeometric_2F0_integer_a2.txt\n # hypergeometric_2F0_ipp/hypergeometric_2F0.txt\n # hypergeometric_2F0_large_z_ipp/hypergeometric_2F0_large_z.txt\n # hypergeometric_2F1_ipp/hypergeometric_2F1.txt\n # hypergeometric_2F2_ipp/hypergeometric_2F2.txt\n\n # ncbeta_big_ipp/ncbeta_big.txt\n # nct_small_delta_ipp/nct_small_delta.txt\n # nct_asym_ipp/nct_asym.txt\n # ncbeta_ipp/ncbeta.txt\n\n # powm1_data_ipp/powm1_big_data.txt\n # powm1_sqrtp1m1_test_hpp/sqrtp1m1_data.txt\n\n # sinc_data_ipp/sinc_data.txt\n\n # test_gamma_data_ipp/gammap1m1_data.txt\n # tgamma_ratio_data_ipp/tgamma_ratio_data.txt\n\n # trig_data_ipp/trig_data.txt\n # trig_data2_ipp/trig_data2.txt\n]\n\n\[email protected]('test', BOOST_TESTS, ids=repr)\ndef test_boost(test):\n _test_factory(test)\n\n\nGSL_TESTS = [\n data_gsl(mathieu_a, 'mathieu_ab', (0, 1), 2, rtol=1e-13, atol=1e-13),\n data_gsl(mathieu_b, 'mathieu_ab', (0, 1), 3, rtol=1e-13, atol=1e-13),\n\n # Also the GSL output has limited accuracy...\n data_gsl(mathieu_ce_rad, 'mathieu_ce_se', (0, 1, 2), 3, rtol=1e-7, atol=1e-13),\n data_gsl(mathieu_se_rad, 'mathieu_ce_se', (0, 1, 2), 4, rtol=1e-7, atol=1e-13),\n\n data_gsl(mathieu_mc1_scaled, 'mathieu_mc_ms', (0, 1, 2), 3, rtol=1e-7, atol=1e-13),\n data_gsl(mathieu_ms1_scaled, 'mathieu_mc_ms', (0, 1, 2), 4, rtol=1e-7, atol=1e-13),\n\n data_gsl(mathieu_mc2_scaled, 'mathieu_mc_ms', (0, 1, 2), 5, rtol=1e-7, atol=1e-13),\n data_gsl(mathieu_ms2_scaled, 'mathieu_mc_ms', (0, 1, 2), 6, rtol=1e-7, atol=1e-13),\n]\n\n\[email protected]('test', GSL_TESTS, ids=repr)\ndef test_gsl(test):\n _test_factory(test)\n\n\nLOCAL_TESTS = [\n data_local(ellipkinc, 'ellipkinc_neg_m', (0, 1), 2),\n data_local(ellipkm1, 'ellipkm1', 0, 1),\n data_local(ellipeinc, 'ellipeinc_neg_m', (0, 1), 2),\n data_local(clog1p, 'log1p_expm1_complex', (0,1), (2,3), rtol=1e-14),\n data_local(cexpm1, 'log1p_expm1_complex', (0,1), (4,5), rtol=1e-14),\n data_local(gammainc, 'gammainc', (0, 1), 2, rtol=1e-12),\n data_local(gammaincc, 'gammaincc', (0, 1), 2, rtol=1e-11),\n data_local(ellip_harm_2, 'ellip',(0, 1, 2, 3, 4), 6, rtol=1e-10, atol=1e-13),\n data_local(ellip_harm, 'ellip',(0, 1, 2, 3, 4), 5, rtol=1e-10, atol=1e-13),\n]\n\n\[email protected]('test', LOCAL_TESTS, ids=repr)\ndef test_local(test):\n _test_factory(test)\n\n\ndef _test_factory(test, dtype=np.double):\n \"\"\"Boost test\"\"\"\n with suppress_warnings() as sup:\n sup.filter(IntegrationWarning, \"The occurrence of roundoff error is detected\")\n with np.errstate(all='ignore'):\n test.check(dtype=dtype)\n" ]	[ [ "scipy.special.mathieu_modcem1", "scipy.special.mathieu_sem", "scipy.special.zeta", "numpy.sqrt", "scipy.special.expm1", "scipy.special.ellipk", "scipy.special.gdtrib", "scipy.special.mathieu_modcem2", "scipy.special.poch", "scipy.special.bdtrik", "scipy.special.mathieu_modsem1", "numpy.testing.suppress_warnings", "scipy.special.lqmn", "scipy.special.sph_harm", "scipy.special.nbdtrik", "scipy.special.lpmn", "scipy.special.mathieu_cem", "scipy.special.ellipj", "scipy.special.pdtrik", "scipy.special.ellipkinc", "scipy.special.log1p", "scipy.special.gdtrc", "scipy.special._testutils.FuncData", "numpy.errstate", "scipy.special.mathieu_modsem2", "numpy.logical_and", "scipy.special.btdtrib", "scipy.special.btdtria", "scipy.special.ellipeinc", "scipy.special.btdtri", "scipy.special.ellipe", "scipy.special.gdtrix", "numpy.ones", "scipy.special.gdtr", "scipy.special.lpmv" ] ]
dahburj/tf2-gnn	[ "ac6247c44957b35a478de4bbe13c0c96e82f0ba1" ]	[ "tf2_gnn/data/jsonl_graph_dataset.py" ]	[ "\"\"\"General dataset class for datasets stored as JSONLines files.\"\"\"\nimport logging\nfrom typing import Any, Dict, Iterator, List, Optional, Tuple, Set\n\nimport numpy as np\nfrom dpu_utils.utils import RichPath\n\nfrom .graph_dataset import DataFold, GraphDataset, GraphSampleType, GraphSample\n\nlogger = logging.getLogger(__name__)\n\n\nclass JsonLGraphDataset(GraphDataset[GraphSampleType]):\n \"\"\"\n General class representing pre-split datasets in JSONLines format.\n Concretely, this class expects the following:\n * In the data directory, files \"train.jsonl.gz\", \"valid.jsonl.gz\" and\n \"test.jsonl.gz\" are used to store the train/valid/test datasets.\n * Each of the files is gzipped text file in which each line is a valid\n JSON dictionary with a \"graph\" key, which in turn points to a\n dictionary with keys\n - \"node_features\" (list of numerical initial node labels)\n - \"adjacency_lists\" (list of list of directed edge pairs)\n \"\"\"\n\n @classmethod\n def get_default_hyperparameters(cls) -> Dict[str, Any]:\n super_hypers = super().get_default_hyperparameters()\n this_hypers = {\n \"num_fwd_edge_types\": 3,\n \"add_self_loop_edges\": True,\n \"tie_fwd_bkwd_edges\": True,\n }\n super_hypers.update(this_hypers)\n return super_hypers\n\n def __init__(\n self, params: Dict[str, Any], metadata: Optional[Dict[str, Any]] = None,\n ):\n super().__init__(params, metadata=metadata)\n self._params = params\n self._num_fwd_edge_types = params[\"num_fwd_edge_types\"]\n if params[\"tie_fwd_bkwd_edges\"]:\n self._num_edge_types = self._num_fwd_edge_types\n else:\n self._num_edge_types = 2 * self._num_fwd_edge_types\n self._num_edge_types += int(params[\"add_self_loop_edges\"])\n\n self._node_feature_shape: Optional[Tuple[int]] = None\n self._loaded_data: Dict[DataFold, List[GraphSampleType]] = {}\n\n @property\n def num_edge_types(self) -> int:\n return self._num_edge_types\n\n @property\n def node_feature_shape(self) -> Tuple:\n \"\"\"Return the shape of the node features.\"\"\"\n if self._node_feature_shape is None:\n some_data_fold = next(iter(self._loaded_data.values()))\n self._node_feature_shape = (len(some_data_fold[0].node_features[0]),)\n return self._node_feature_shape\n\n def load_metadata(self, path: RichPath) -> None:\n \"\"\"Load the metadata for a dataset (such as vocabularies, names of properties, ...)\n from a path on disk.\n\n Note: Implementors needing to act on metadata information before loading any actual data\n should override this method.\n \"\"\"\n if self.metadata == {}:\n metadata_path = path.join(\"metadata.pkl.gz\")\n if metadata_path.exists():\n logger.info(f\"Loading metadata from {metadata_path}\")\n self._metadata = metadata_path.read_by_file_suffix()\n else:\n logger.warning(\"Using metadata passed to constructor, not metadata stored with data.\")\n\n def load_data(self, path: RichPath, folds_to_load: Optional[Set[DataFold]] = None) -> None:\n \"\"\"Load the data from disk.\"\"\"\n logger.info(f\"Starting to load data from {path}.\")\n self.load_metadata(path)\n\n # If we haven't defined what folds to load, load all:\n if folds_to_load is None:\n folds_to_load = {DataFold.TRAIN, DataFold.VALIDATION, DataFold.TEST}\n\n if DataFold.TRAIN in folds_to_load:\n self._loaded_data[DataFold.TRAIN] = self.__load_data(path.join(\"train.jsonl.gz\"))\n logger.debug(\"Done loading training data.\")\n if DataFold.VALIDATION in folds_to_load:\n self._loaded_data[DataFold.VALIDATION] = self.__load_data(path.join(\"valid.jsonl.gz\"))\n logger.debug(\"Done loading validation data.\")\n if DataFold.TEST in folds_to_load:\n self._loaded_data[DataFold.TEST] = self.__load_data(path.join(\"test.jsonl.gz\"))\n logger.debug(\"Done loading test data.\")\n\n def load_data_from_list(\n self, datapoints: List[Dict[str, Any]], target_fold: DataFold = DataFold.TEST\n ):\n if target_fold not in self._loaded_data:\n self._loaded_data[target_fold] = []\n for datapoint in datapoints:\n self._loaded_data[target_fold].append(self._process_raw_datapoint(datapoint))\n\n def __load_data(self, data_file: RichPath) -> List[GraphSampleType]:\n return [\n self._process_raw_datapoint(datapoint) for datapoint in data_file.read_by_file_suffix()\n ]\n\n def _process_raw_datapoint(self, datapoint: Dict[str, Any]) -> GraphSampleType:\n node_features = datapoint[\"graph\"][\"node_features\"]\n type_to_adj_list, type_to_num_incoming_edges = self._process_raw_adjacency_lists(\n raw_adjacency_lists=datapoint[\"graph\"][\"adjacency_lists\"],\n num_nodes=len(node_features),\n )\n\n return GraphSample(\n adjacency_lists=type_to_adj_list,\n type_to_node_to_num_inedges=type_to_num_incoming_edges,\n node_features=node_features,\n )\n\n def _process_raw_adjacency_lists(\n self, raw_adjacency_lists: List[List[Tuple]], num_nodes: int\n ) -> Tuple[List, np.ndarray]:\n type_to_adj_list = [\n [] for _ in range(self._num_fwd_edge_types + int(self.params[\"add_self_loop_edges\"]))\n ] # type: List[List[Tuple[int, int]]]\n type_to_num_incoming_edges = np.zeros(shape=(self.num_edge_types, num_nodes))\n for raw_edge_type, edges in enumerate(raw_adjacency_lists):\n if self.params[\"add_self_loop_edges\"]:\n fwd_edge_type = raw_edge_type + 1 # 0 will be the self-loop type\n else:\n fwd_edge_type = raw_edge_type # Make edges start from 0\n for src, dest in edges:\n type_to_adj_list[fwd_edge_type].append((src, dest))\n type_to_num_incoming_edges[fwd_edge_type, dest] += 1\n if self.params[\"tie_fwd_bkwd_edges\"]:\n type_to_adj_list[fwd_edge_type].append((dest, src))\n type_to_num_incoming_edges[fwd_edge_type, src] += 1\n\n if self.params[\"add_self_loop_edges\"]:\n # Add self-loop edges (idx 0, which isn't used in the data):\n for node in range(num_nodes):\n type_to_num_incoming_edges[0, node] = 1\n type_to_adj_list[0].append((node, node))\n\n # Add backward edges as an additional edge type that goes backwards:\n if not (self.params[\"tie_fwd_bkwd_edges\"]):\n # for (edge_type, adj_list) in enumerate(type_to_adj_list):\n num_edge_types_in_adj_lists = len(type_to_adj_list)\n for edge_type in range(num_edge_types_in_adj_lists):\n adj_list = type_to_adj_list[edge_type]\n # Don't add self loops again!\n if edge_type == 0 and self.params[\"add_self_loop_edges\"]:\n continue\n bkwd_edge_type = len(type_to_adj_list)\n type_to_adj_list.append([(y, x) for (x, y) in adj_list])\n for (x, y) in adj_list:\n type_to_num_incoming_edges[bkwd_edge_type][y] += 1\n\n # Convert the adjacency lists to numpy arrays.\n type_to_adj_list = [\n np.array(adj_list, dtype=np.int32)\n if len(adj_list) > 0\n else np.zeros(shape=(0, 2), dtype=np.int32)\n for adj_list in type_to_adj_list\n ]\n return type_to_adj_list, type_to_num_incoming_edges\n\n def _graph_iterator(self, data_fold: DataFold) -> Iterator[GraphSampleType]:\n if data_fold == DataFold.TRAIN:\n np.random.shuffle(self._loaded_data[data_fold])\n return iter(self._loaded_data[data_fold])\n" ]	[ [ "numpy.array", "numpy.zeros", "numpy.random.shuffle" ] ]
TheLortex/rust-mcts	[ "10d0700cef7df7059b7cbacc609d173580203fa9" ]	[ "settings.py" ]	[ "\ndef dir_name(config, method):\n if config.game.kind == \"Breakthrough\":\n return \"{}-breakthrough-{}\".format(method, config.game.size)\n elif config.game.kind == \"Gym\":\n return \"{}-gym-{}\".format(method, config.game.name)\n else:\n print(\"Unknown game in config file.\")\n exit(-1)\n\ndef get_board_shape(config):\n if config.game.kind == \"Breakthrough\":\n return (config.game.history, config.game.size, config.game.size, 3)\n elif config.game.kind == \"Gym\":\n if config.game.name == \"Breakout-v0\":\n return (config.game.history, 96, 96, 3)\n else:\n print(\"Gym not implemented for this game.\")\n exit(-1)\n else:\n print(\"Unknown game in config file.\")\n exit(-1)\n\ndef get_action_shape(config):\n if config.game.kind == \"Breakthrough\":\n return (config.game.size, config.game.size, 3)\n elif config.game.kind == \"Gym\":\n if config.game.name == \"Breakout-v0\":\n return (4,)\n else:\n print(\"Gym not implemented for this game.\")\n exit(-1)\n else:\n print(\"Unknown game in config file.\")\n exit(-1)\n\n \nimport numpy as np\n# scalar to categorical transformation.\ndef value_to_support(v, support_size):\n # invertible transformation\n scaled = np.sign(v) * ((np.sqrt(np.abs(v)+1)-1)) + 0.001v\n # clamp to support\n clamped = np.clip(scaled, -support_size, support_size)\n\n v1 = np.floor(clamped)\n p1 = 1 - (clamped - v1)\n v2 = v1 + 1\n p2 = 1 - p1\n\n result = np.zeros(shape=(support_size2+1,))\n result[int(v1) + support_size] = p1\n if int(v2) + support_size < support_size2+1:\n result[int(v2) + support_size] = p2\n return result\n \nfrom tensorflow.keras import losses\ndef mu_loss_unrolled_cce(config):\n def loss(y_true, y_pred):\n policy_loss = 0.\n\n for i in range(config.mu.unroll_steps):\n policy_loss += losses.categorical_crossentropy(\n y_true[:, i], y_pred[:, i]) / config.mu.unroll_steps\n\n return policy_loss\n return loss\n\ndef get_support_shape(x):\n return (x or 0)2+1\n\"\"\"\n## GAME SETTINGS, make sure this is coherent with the generator and evaluator\nGAME = \"breakthrough\"\n\nif GAME == \"breakthrough\":\n BT_K = 5\n HISTORY_LENGTH = 2\n BOARD_SHAPE = (HISTORY_LENGTH, BT_K, BT_K, 3)\n ACTION_PLANES = 3\n ACTION_SHAPE = (BT_K, BT_K, ACTION_PLANES)\n HIDDEN_PLANES = 16\n HIDDEN_SHAPE = (BT_K, BT_K, HIDDEN_PLANES)\n SUPPORT_SIZE = 1\nelif GAME == \"atari\":\n HISTORY_LENGTH = 8\n BOARD_SHAPE = (HISTORY_LENGTH, 96, 96, 3)\n ACTION_PLANES = 4 # breakout\n ACTION_SHAPE = (ACTION_PLANES, )\n HIDDEN_PLANES = 16\n HIDDEN_SHAPE = (6, 6, HIDDEN_PLANES)\n SUPPORT_SIZE = 300\n\nSUPPORT_SHAPE = 2SUPPORT_SIZE+1\n\n\n# MUZERO SPECIFIC\nN_UNROLL_STEPS = 5\nN_TD_STEPS = 300\nDISCOUNT = 0.997\n\nWEIGHT_DECAY = 1e-4\n\nREPLAY_BUFFER_SIZE = 5000 # SAVE THE LAST 5k GAMES\nEPOCH_SIZE = 5REPLAY_BUFFER_SIZE\nBATCH_SIZE = 512\nN_EPOCH = 50000\n\nSAVE_REPLAY_BUFFER_FREQ = 64 # backup replay buffer every _ games\nCHECKPOINT_FREQ = 5EPOCH_SIZE # save model\nEVALUATION_FREQ = 5EPOCH_SIZE # evaluate model\n\"\"\"" ]	[ [ "numpy.abs", "numpy.clip", "tensorflow.keras.losses.categorical_crossentropy", "numpy.sign", "numpy.floor", "numpy.zeros" ] ]
makra89/Quake_AI	[ "8df69c75b117079f5e40929341c4638e741de11d" ]	[ "yolov3_tf2/models.py" ]	[ "import numpy as np\nimport tensorflow as tf\nfrom tensorflow.keras import Model\nfrom tensorflow.keras.layers import (\n Add,\n Concatenate,\n Conv2D,\n Input,\n Lambda,\n LeakyReLU,\n MaxPool2D,\n UpSampling2D,\n ZeroPadding2D,\n BatchNormalization,\n)\nfrom tensorflow.keras.regularizers import l2\nfrom tensorflow.keras.losses import (\n binary_crossentropy,\n sparse_categorical_crossentropy\n)\nfrom .utils import broadcast_iou\n\n# TODO: Add these values to config?\nYOLO_MAX_BOXES = 100\nYOLO_IOU_THRESHOLD = 0.5\nYOLO_SCORE_THRESHOLD = 0.5\n\nyolo_anchors = np.array([(10, 13), (16, 30), (33, 23), (30, 61), (62, 45),\n (59, 119), (116, 90), (156, 198), (373, 326)],\n np.float32) / 416\nyolo_anchor_masks = yolo_tiny_3l_anchor_masks = np.array([[6, 7, 8], [3, 4, 5], [0, 1, 2]])\n\nyolo_tiny_3l_anchors = np.array([(11, 20), (15, 31), (16, 56), (24, 44), (27, 70),\n (35, 101), (51, 120), (71, 179), (132, 245)],\n np.float32) / 416\n\n# Determined for custom dataset\nyolo_tiny_anchors = np.array([(14, 28), (22, 54), (30, 87),\n (45, 95), (52, 145), (106, 216)],\n np.float32) / 416\nyolo_tiny_anchor_masks = np.array([[3, 4, 5], [0, 1, 2]])\n\n\ndef DarknetConv(x, filters, size, strides=1, batch_norm=True):\n if strides == 1:\n padding = 'same'\n else:\n x = ZeroPadding2D(((1, 0), (1, 0)))(x) # top left half-padding\n padding = 'valid'\n x = Conv2D(filters=filters, kernel_size=size,\n strides=strides, padding=padding,\n use_bias=not batch_norm, kernel_regularizer=l2(0.0005))(x)\n if batch_norm:\n x = BatchNormalization()(x)\n x = LeakyReLU(alpha=0.1)(x)\n return x\n\n\ndef DarknetResidual(x, filters):\n prev = x\n x = DarknetConv(x, filters // 2, 1)\n x = DarknetConv(x, filters, 3)\n x = Add()([prev, x])\n return x\n\n\ndef DarknetBlock(x, filters, blocks):\n x = DarknetConv(x, filters, 3, strides=2)\n for _ in range(blocks):\n x = DarknetResidual(x, filters)\n return x\n\n\ndef Darknet(name=None):\n x = inputs = Input([None, None, 3])\n x = DarknetConv(x, 32, 3)\n x = DarknetBlock(x, 64, 1)\n x = DarknetBlock(x, 128, 2) # skip connection\n x = x_36 = DarknetBlock(x, 256, 8) # skip connection\n x = x_61 = DarknetBlock(x, 512, 8)\n x = DarknetBlock(x, 1024, 4)\n return tf.keras.Model(inputs, (x_36, x_61, x), name=name)\n\n\ndef DarknetTiny(name=None):\n x = inputs = Input([None, None, 3])\n x = DarknetConv(x, 16, 3)\n x = MaxPool2D(2, 2, 'same')(x)\n x = DarknetConv(x, 32, 3)\n x = MaxPool2D(2, 2, 'same')(x)\n x = DarknetConv(x, 64, 3)\n x = MaxPool2D(2, 2, 'same')(x)\n x = DarknetConv(x, 128, 3)\n x = MaxPool2D(2, 2, 'same')(x)\n x = x_8 = DarknetConv(x, 256, 3) # skip connection\n x = MaxPool2D(2, 2, 'same')(x)\n x = DarknetConv(x, 512, 3)\n x = MaxPool2D(2, 1, 'same')(x)\n x = DarknetConv(x, 1024, 3)\n return tf.keras.Model(inputs, (x_8, x), name=name)\n\ndef DarknetTiny3L(name=None):\n x = inputs = Input([None, None, 3])\n x = DarknetConv(x, 16, 3)\n x = MaxPool2D(2, 2, 'same')(x)\n x = DarknetConv(x, 32, 3)\n x = MaxPool2D(2, 2, 'same')(x)\n x = DarknetConv(x, 64, 3)\n x = MaxPool2D(2, 2, 'same')(x)\n x = x_6 = DarknetConv(x, 128, 3)\n x = MaxPool2D(2, 2, 'same')(x)\n x = x_8 = DarknetConv(x, 256, 3) # skip connection\n x = MaxPool2D(2, 2, 'same')(x)\n x = DarknetConv(x, 512, 3)\n x = MaxPool2D(2, 1, 'same')(x)\n x = DarknetConv(x, 1024, 3)\n return tf.keras.Model(inputs, (x_6, x_8, x), name=name)\n\n\ndef YoloConv(filters, name=None):\n def yolo_conv(x_in):\n if isinstance(x_in, tuple):\n inputs = Input(x_in[0].shape[1:]), Input(x_in[1].shape[1:])\n x, x_skip = inputs\n\n # concat with skip connection\n x = DarknetConv(x, filters, 1)\n x = UpSampling2D(2)(x)\n x = Concatenate()([x, x_skip])\n else:\n x = inputs = Input(x_in.shape[1:])\n\n x = DarknetConv(x, filters, 1)\n x = DarknetConv(x, filters * 2, 3)\n x = DarknetConv(x, filters, 1)\n x = DarknetConv(x, filters * 2, 3)\n x = DarknetConv(x, filters, 1)\n return Model(inputs, x, name=name)(x_in)\n return yolo_conv\n\n\ndef YoloConvTiny(filters, name=None):\n def yolo_conv(x_in):\n if isinstance(x_in, tuple):\n inputs = Input(x_in[0].shape[1:]), Input(x_in[1].shape[1:])\n x, x_skip = inputs\n\n # concat with skip connection\n x = DarknetConv(x, filters, 1)\n x = UpSampling2D(2)(x)\n x = Concatenate()([x, x_skip])\n else:\n x = inputs = Input(x_in.shape[1:])\n x = DarknetConv(x, filters, 1)\n\n return Model(inputs, x, name=name)(x_in)\n return yolo_conv\n\n\ndef YoloOutput(filters, anchors, classes, name=None):\n def yolo_output(x_in):\n x = inputs = Input(x_in.shape[1:])\n x = DarknetConv(x, filters * 2, 3)\n x = DarknetConv(x, anchors * (classes + 5), 1, batch_norm=False)\n x = Lambda(lambda x: tf.reshape(x, (-1, tf.shape(x)[1], tf.shape(x)[2],\n anchors, classes + 5)))(x)\n return tf.keras.Model(inputs, x, name=name)(x_in)\n return yolo_output\n\n\n# As tensorflow lite doesn't support tf.size used in tf.meshgrid, \n# we reimplemented a simple meshgrid function that use basic tf function.\ndef _meshgrid(n_a, n_b):\n\n return [\n tf.reshape(tf.tile(tf.range(n_a), [n_b]), (n_b, n_a)),\n tf.reshape(tf.repeat(tf.range(n_b), n_a), (n_b, n_a))\n ]\n\n\ndef yolo_boxes(pred, anchors, classes):\n # pred: (batch_size, grid, grid, anchors, (x, y, w, h, obj, ...classes))\n grid_size = tf.shape(pred)[1:3]\n box_xy, box_wh, objectness, class_probs = tf.split(\n pred, (2, 2, 1, classes), axis=-1)\n\n box_xy = tf.sigmoid(box_xy)\n objectness = tf.sigmoid(objectness)\n class_probs = tf.sigmoid(class_probs)\n pred_box = tf.concat((box_xy, box_wh), axis=-1) # original xywh for loss\n\n # !!! grid[x][y] == (y, x)\n grid = _meshgrid(grid_size[1],grid_size[0])\n grid = tf.expand_dims(tf.stack(grid, axis=-1), axis=2) # [gx, gy, 1, 2]\n\n box_xy = (box_xy + tf.cast(grid, tf.float32)) / \\\n tf.cast(grid_size, tf.float32)\n box_wh = tf.exp(box_wh) * anchors\n\n box_x1y1 = box_xy - box_wh / 2\n box_x2y2 = box_xy + box_wh / 2\n bbox = tf.concat([box_x1y1, box_x2y2], axis=-1)\n\n return bbox, objectness, class_probs, pred_box\n\n\ndef yolo_nms(outputs, anchors, masks, classes):\n # boxes, conf, type\n b, c, t = [], [], []\n\n for o in outputs:\n b.append(tf.reshape(o[0], (tf.shape(o[0])[0], -1, tf.shape(o[0])[-1])))\n c.append(tf.reshape(o[1], (tf.shape(o[1])[0], -1, tf.shape(o[1])[-1])))\n t.append(tf.reshape(o[2], (tf.shape(o[2])[0], -1, tf.shape(o[2])[-1])))\n\n bbox = tf.concat(b, axis=1)\n confidence = tf.concat(c, axis=1)\n class_probs = tf.concat(t, axis=1)\n\n # If we only have one class, do not multiply by class_prob (always 0.5)\n if classes == 1:\n scores = confidence\n else:\n scores = confidence * class_probs\n\n dscores = tf.squeeze(scores, axis=0)\n scores = tf.reduce_max(dscores,[1])\n bbox = tf.reshape(bbox,(-1,4))\n classes = tf.argmax(dscores,1)\n selected_indices, selected_scores = tf.image.non_max_suppression_with_scores(\n boxes=bbox,\n scores=scores,\n max_output_size=YOLO_MAX_BOXES,\n iou_threshold=YOLO_IOU_THRESHOLD,\n score_threshold=YOLO_SCORE_THRESHOLD,\n soft_nms_sigma=0.5\n )\n \n num_valid_nms_boxes = tf.shape(selected_indices)[0]\n\n selected_indices = tf.concat([selected_indices,tf.zeros(YOLO_MAX_BOXES-num_valid_nms_boxes, tf.int32)], 0)\n selected_scores = tf.concat([selected_scores,tf.zeros(YOLO_MAX_BOXES-num_valid_nms_boxes,tf.float32)], -1)\n\n boxes=tf.gather(bbox, selected_indices)\n boxes = tf.expand_dims(boxes, axis=0)\n scores=selected_scores\n scores = tf.expand_dims(scores, axis=0)\n classes = tf.gather(classes,selected_indices)\n classes = tf.expand_dims(classes, axis=0)\n valid_detections=num_valid_nms_boxes\n valid_detections = tf.expand_dims(valid_detections, axis=0)\n\n return boxes, scores, classes, valid_detections\n\n\ndef YoloV3(size=None, channels=3, anchors=yolo_anchors,\n masks=yolo_anchor_masks, classes=80, training=False):\n x = inputs = Input([size, size, channels], name='input')\n\n x_36, x_61, x = Darknet(name='yolo_darknet')(x)\n\n x = YoloConv(512, name='yolo_conv_0')(x)\n output_0 = YoloOutput(512, len(masks[0]), classes, name='yolo_output_0')(x)\n\n x = YoloConv(256, name='yolo_conv_1')((x, x_61))\n output_1 = YoloOutput(256, len(masks[1]), classes, name='yolo_output_1')(x)\n\n x = YoloConv(128, name='yolo_conv_2')((x, x_36))\n output_2 = YoloOutput(128, len(masks[2]), classes, name='yolo_output_2')(x)\n\n if training:\n return Model(inputs, (output_0, output_1, output_2), name='yolov3')\n\n boxes_0 = Lambda(lambda x: yolo_boxes(x, anchors[masks[0]], classes),\n name='yolo_boxes_0')(output_0)\n boxes_1 = Lambda(lambda x: yolo_boxes(x, anchors[masks[1]], classes),\n name='yolo_boxes_1')(output_1)\n boxes_2 = Lambda(lambda x: yolo_boxes(x, anchors[masks[2]], classes),\n name='yolo_boxes_2')(output_2)\n\n outputs = Lambda(lambda x: yolo_nms(x, anchors, masks, classes),\n name='yolo_nms')((boxes_0[:3], boxes_1[:3], boxes_2[:3]))\n\n return Model(inputs, outputs, name='yolov3')\n\n\ndef YoloV3Tiny(size=None, channels=3, anchors=yolo_tiny_anchors,\n masks=yolo_tiny_anchor_masks, classes=80, training=False):\n x = inputs = Input([size, size, channels], name='input')\n\n x_8, x = DarknetTiny(name='yolo_darknet')(x)\n\n x = YoloConvTiny(256, name='yolo_conv_0')(x)\n output_0 = YoloOutput(256, len(masks[0]), classes, name='yolo_output_0')(x)\n\n x = YoloConvTiny(128, name='yolo_conv_1')((x, x_8))\n output_1 = YoloOutput(128, len(masks[1]), classes, name='yolo_output_1')(x)\n\n if training:\n return Model(inputs, (output_0, output_1), name='yolov3')\n\n boxes_0 = Lambda(lambda x: yolo_boxes(x, anchors[masks[0]], classes),\n name='yolo_boxes_0')(output_0)\n boxes_1 = Lambda(lambda x: yolo_boxes(x, anchors[masks[1]], classes),\n name='yolo_boxes_1')(output_1)\n outputs = Lambda(lambda x: yolo_nms(x, anchors, masks, classes),\n name='yolo_nms')((boxes_0[:3], boxes_1[:3]))\n return Model(inputs, outputs, name='yolov3_tiny')\n\n\ndef YoloV3Tiny3L(size=None, channels=3, anchors=yolo_tiny_3l_anchors,\n masks=yolo_tiny_3l_anchor_masks, classes=80, training=False):\n x = inputs = Input([size, size, channels], name='input')\n\n x_6, x_8, x = DarknetTiny3L(name='yolo_darknet')(x)\n\n x = YoloConvTiny(256, name='yolo_conv_0')(x)\n output_0 = YoloOutput(256, len(masks[0]), classes, name='yolo_output_0')(x)\n\n x = YoloConvTiny(128, name='yolo_conv_1')((x, x_8))\n output_1 = YoloOutput(128, len(masks[1]), classes, name='yolo_output_1')(x)\n\n x = YoloConvTiny(128, name='yolo_conv_2')((x, x_6))\n output_2 = YoloOutput(64, len(masks[2]), classes, name='yolo_output_2')(x)\n\n if training:\n return Model(inputs, (output_0, output_1, output_2), name='yolov3')\n\n boxes_0 = Lambda(lambda x: yolo_boxes(x, anchors[masks[0]], classes),\n name='yolo_boxes_0')(output_0)\n boxes_1 = Lambda(lambda x: yolo_boxes(x, anchors[masks[1]], classes),\n name='yolo_boxes_1')(output_1)\n boxes_2 = Lambda(lambda x: yolo_boxes(x, anchors[masks[2]], classes),\n name='yolo_boxes_2')(output_2)\n\n outputs = Lambda(lambda x: yolo_nms(x, anchors, masks, classes),\n name='yolo_nms')((boxes_0[:3], boxes_1[:3], boxes_2[:3]))\n\n return Model(inputs, outputs, name='yolov3_tiny_3l')\n\ndef YoloLoss(anchors, classes=80, ignore_thresh=0.5):\n def yolo_loss(y_true, y_pred):\n # 1. transform all pred outputs\n # y_pred: (batch_size, grid, grid, anchors, (x, y, w, h, obj, ...cls))\n pred_box, pred_obj, pred_class, pred_xywh = yolo_boxes(\n y_pred, anchors, classes)\n pred_xy = pred_xywh[..., 0:2]\n pred_wh = pred_xywh[..., 2:4]\n\n # 2. transform all true outputs\n # y_true: (batch_size, grid, grid, anchors, (x1, y1, x2, y2, obj, cls))\n true_box, true_obj, true_class_idx = tf.split(\n y_true, (4, 1, 1), axis=-1)\n true_xy = (true_box[..., 0:2] + true_box[..., 2:4]) / 2\n true_wh = true_box[..., 2:4] - true_box[..., 0:2]\n\n # give higher weights to small boxes\n box_loss_scale = 2 - true_wh[..., 0] * true_wh[..., 1]\n\n # 3. inverting the pred box equations\n grid_size = tf.shape(y_true)[1]\n grid = tf.meshgrid(tf.range(grid_size), tf.range(grid_size))\n grid = tf.expand_dims(tf.stack(grid, axis=-1), axis=2)\n true_xy = true_xy * tf.cast(grid_size, tf.float32) - \\\n tf.cast(grid, tf.float32)\n true_wh = tf.math.log(true_wh / anchors)\n true_wh = tf.where(tf.math.is_inf(true_wh),\n tf.zeros_like(true_wh), true_wh)\n\n # 4. calculate all masks\n obj_mask = tf.squeeze(true_obj, -1)\n # ignore false positive when iou is over threshold\n best_iou = tf.map_fn(\n lambda x: tf.reduce_max(broadcast_iou(x[0], tf.boolean_mask(\n x[1], tf.cast(x[2], tf.bool))), axis=-1),\n (pred_box, true_box, obj_mask),\n tf.float32)\n ignore_mask = tf.cast(best_iou < ignore_thresh, tf.float32)\n\n # 5. calculate all losses\n xy_loss = obj_mask * box_loss_scale * \\\n tf.reduce_sum(tf.square(true_xy - pred_xy), axis=-1)\n wh_loss = obj_mask * box_loss_scale * \\\n tf.reduce_sum(tf.square(true_wh - pred_wh), axis=-1)\n obj_loss = binary_crossentropy(true_obj, pred_obj)\n obj_loss = obj_mask * obj_loss + \\\n (1 - obj_mask) * ignore_mask * obj_loss\n class_loss = obj_mask * sparse_categorical_crossentropy(\n true_class_idx, pred_class)\n\n # 6. sum over (batch, gridx, gridy, anchors) => (batch, 1)\n xy_loss = tf.reduce_sum(xy_loss, axis=(1, 2, 3))\n wh_loss = tf.reduce_sum(wh_loss, axis=(1, 2, 3))\n obj_loss = tf.reduce_sum(obj_loss, axis=(1, 2, 3))\n class_loss = tf.reduce_sum(class_loss, axis=(1, 2, 3))\n\n return xy_loss + wh_loss + obj_loss + class_loss\n return yolo_loss\n" ]	[ [ "tensorflow.concat", "tensorflow.zeros", "tensorflow.stack", "tensorflow.reduce_sum", "tensorflow.cast", "tensorflow.keras.layers.ZeroPadding2D", "tensorflow.keras.layers.Concatenate", "tensorflow.keras.layers.LeakyReLU", "tensorflow.keras.regularizers.l2", "tensorflow.keras.layers.UpSampling2D", "tensorflow.squeeze", "tensorflow.gather", "tensorflow.square", "tensorflow.keras.layers.Add", "tensorflow.argmax", "tensorflow.math.is_inf", "tensorflow.shape", "tensorflow.keras.losses.sparse_categorical_crossentropy", "tensorflow.exp", "tensorflow.keras.Model", "tensorflow.zeros_like", "tensorflow.keras.losses.binary_crossentropy", "tensorflow.split", "numpy.array", "tensorflow.reduce_max", "tensorflow.range", "tensorflow.reshape", "tensorflow.sigmoid", "tensorflow.expand_dims", "tensorflow.image.non_max_suppression_with_scores", "tensorflow.keras.layers.MaxPool2D", "tensorflow.math.log", "tensorflow.keras.layers.BatchNormalization", "tensorflow.keras.layers.Input" ] ]
ASVincent/wagl	[ "cf3a72e53e53f3a7b2f2b5308068069b1b714f2a" ]	[ "wagl/data.py" ]	[ "\"\"\"\nData access functions\n---------------------\n\"\"\"\n\nfrom __future__ import absolute_import\nfrom os.path import join as pjoin, basename, dirname\nimport subprocess\nimport tempfile\nimport logging\nimport numpy as np\nimport h5py\nimport rasterio\n\nfrom rasterio.crs import CRS\nfrom rasterio.warp import reproject\nfrom rasterio.enums import Resampling\nfrom wagl.geobox import GriddedGeoBox\nfrom wagl.tiling import generate_tiles\n\n\ndef get_pixel(filename, lonlat, band=1):\n \"\"\"Return a pixel from `filename` at the longitude and latitude given\n by the tuple `lonlat`. Optionally, the `band` can be specified.\"\"\"\n with rasterio.open(filename) as src:\n x, y = [int(v) for v in ~src.transform * lonlat]\n if isinstance(band, list):\n data = src.read(band, window=((y, y + 1), (x, x + 1))).ravel()\n else:\n data = src.read(band, window=((y, y + 1), (x, x + 1))).flat[0]\n return data\n\n\ndef select_acquisitions(acqs_list, fn=(lambda acq: True)):\n \"\"\"\n Given a list of acquisitions, apply the supplied fn to select the\n desired acquisitions.\n \"\"\"\n acqs = [acq for acq in acqs_list if fn(acq)]\n return acqs\n\n\ndef stack_data(acqs_list, fn=(lambda acq: True), window=None, masked=False):\n \"\"\"\n Given a list of acquisitions, return the data from each acquisition\n collected in a 3D numpy array (first index is the acquisition number).\n If window is defined, then the subset contained within the window is\n returned along with a GriddedGeoBox instance detailing the \n spatial information associated with that subset.\n\n :param acqs_list:\n The list of acquisitions from which to generate a stack of data.\n\n :param window:\n Defines a subset ((ystart, yend), (xstart, xend)) in array\n co-ordinates. Default is None.\n\n :param masked:\n Indicates whether or not to return a masked array. Default is False.\n\n :return:\n A 2-tuple containing:\n\n * 1. A 3D numpy array (or None) containing the corresponding\n acquisition data. (None if no data).\n * 2. A GriddedGeoBox instance specifying the spatial context\n of the 3D numpy array. Note: All Acquisitions share the\n same GriddedGeoBox.\n \"\"\"\n # determine data type and dimensions by reading the first band\n acqs = acqs_list\n a, geo_box = acqs[0].data_and_box(window=window, masked=masked)\n\n # create the result array, setting datatype based on source type\n\n stack_shape = (len(acqs), a.shape[0], a.shape[1])\n stack = np.empty(stack_shape, a.dtype)\n stack[0] = a\n del a\n\n # read remaining aquisitions into it\n\n for i in range(1, stack_shape[0]):\n # can't use this statement because it will cause data to be\n # resampled. But we want an exception thrown if the user\n # tries to stack irreqular aquisitions\n stack[i] = acqs[i].data(window=window, masked=masked)\n\n return stack, geo_box\n\n\ndef write_img(array, filename, driver='GTiff', geobox=None, nodata=None,\n tags=None, options=None, cogtif=False, levels=None,\n resampling=Resampling.nearest):\n \"\"\"\n Writes a 2D/3D image to disk using rasterio.\n\n :param array:\n A 2D/3D NumPy array.\n\n :param filename:\n A string containing the output file name.\n\n :param driver:\n A string containing a GDAL compliant image driver. Default is\n 'GTiff'.\n\n :param geobox:\n An instance of a GriddedGeoBox object.\n\n :param nodata:\n A value representing the no data value for the array.\n\n :param tags:\n A dictionary of dataset-level metadata.\n\n :param options:\n A dictionary containing other dataset creation options.\n See creation options for the respective GDAL formats.\n\n :param cogtif:\n If set to True, override the `driver` keyword with `GTiff`\n and create a Cloud Optimised GeoTiff. Default is False.\n See:\n https://trac.osgeo.org/gdal/wiki/CloudOptimizedGeoTIFF\n\n :param levels:\n If cogtif is set to True, build overviews/pyramids\n according to levels. Default levels are [2, 4, 8, 16, 32].\n\n :param resampling:\n If cogtif is set to True, build overviews/pyramids using\n a resampling method from `rasterio.enums.Resampling`.\n Default is `Resampling.nearest`.\n\n :notes:\n If array is an instance of a `h5py.Dataset`, then the output\n file will include blocksizes based on the `h5py.Dataset's`\n chunks. To override the blocksizes, specify them using the\n `options` keyword. Eg {'blockxsize': 512, 'blockysize': 512}.\n If `cogtif` is set to True, the default blocksizes will be\n 256x256. To override this behaviour, specify them using the\n `options` keyword. Eg {'blockxsize': 512, 'blockysize': 512}.\n \"\"\"\n # Get the datatype of the array\n dtype = array.dtype.name\n\n # Check for excluded datatypes\n excluded_dtypes = ['int64', 'int8', 'uint64']\n if dtype in excluded_dtypes:\n msg = \"Datatype not supported: {dt}\".format(dt=dtype)\n raise TypeError(msg)\n\n # convert any bools to uin8\n if dtype == 'bool':\n array = np.uint8(array)\n dtype = 'uint8'\n\n ndims = array.ndim\n dims = array.shape\n\n # Get the (z, y, x) dimensions (assuming BSQ interleave)\n if ndims == 2:\n samples = dims[1]\n lines = dims[0]\n bands = 1\n elif ndims == 3:\n samples = dims[2]\n lines = dims[1]\n bands = dims[0]\n else:\n logging.error('Input array is not of 2 or 3 dimensions!!!')\n err = 'Array dimensions: {dims}'.format(dims=ndims)\n raise IndexError(err)\n\n # If we have a geobox, then retrieve the geotransform and projection\n if geobox is not None:\n transform = geobox.transform\n projection = geobox.crs.ExportToWkt()\n else:\n transform = None\n projection = None\n\n # override the driver if we are creating a cogtif\n if cogtif:\n driver = 'GTiff'\n\n # compression predictor choices\n predictor = {'int8': 2,\n 'uint8': 2,\n 'int16': 2,\n 'uint16': 2,\n 'int32': 2,\n 'uint32': 2,\n 'int64': 2,\n 'uint64': 2,\n 'float32': 3,\n 'float64': 3}\n\n kwargs = {'count': bands,\n 'width': samples,\n 'height': lines,\n 'crs': projection,\n 'transform': transform,\n 'dtype': dtype,\n 'driver': driver,\n 'nodata': nodata,\n 'predictor': predictor[dtype]}\n\n if isinstance(array, h5py.Dataset):\n # TODO: if array is 3D get x & y chunks\n if array.chunks[1] == array.shape[1]:\n # GDAL doesn't like tiled or blocksize options to be set\n # the same length as the columns (probably true for rows as well)\n array = array[:]\n else:\n y_tile, x_tile = array.chunks\n tiles = generate_tiles(samples, lines, x_tile, y_tile)\n\n # add blocksizes to the creation keywords\n kwargs['tiled'] = 'yes'\n kwargs['blockxsize'] = x_tile\n kwargs['blockysize'] = y_tile\n\n # the user can override any derived blocksizes by supplying `options`\n if options is not None:\n for key in options:\n kwargs[key] = options[key]\n\n with tempfile.TemporaryDirectory() as tmpdir:\n out_fname = pjoin(tmpdir, basename(filename)) if cogtif else filename\n\n with rasterio.open(out_fname, 'w', kwargs) as outds:\n if bands == 1:\n if isinstance(array, h5py.Dataset):\n for tile in tiles:\n idx = (slice(tile[0][0], tile[0][1]),\n slice(tile[1][0], tile[1][1]))\n outds.write(array[idx], 1, window=tile)\n else:\n outds.write(array, 1)\n else:\n if isinstance(array, h5py.Dataset):\n for tile in tiles:\n idx = (slice(tile[0][0], tile[0][1]),\n slice(tile[1][0], tile[1][1]))\n subs = array[:, idx[0], idx[1]]\n for i in range(bands):\n outds.write(subs[i], i + 1, window=tile)\n else:\n for i in range(bands):\n outds.write(array[i], i + 1)\n if tags is not None:\n outds.update_tags(tags)\n\n # overviews/pyramids\n if cogtif:\n if levels is None:\n levels = [2, 4, 8, 16, 32]\n outds.build_overviews(levels, resampling)\n\n if cogtif:\n cmd = ['gdal_translate',\n '-co',\n 'TILED=YES',\n '-co',\n 'COPY_SRC_OVERVIEWS=YES',\n '-co',\n '{}={}'.format('PREDICTOR', predictor[dtype])]\n\n for key, value in options.items():\n cmd.extend(['-co', '{}={}'.format(key, value)])\n\n cmd.extend([out_fname, filename])\n\n subprocess.check_call(cmd, cwd=dirname(filename))\n\n\ndef read_subset(fname, ul_xy, ur_xy, lr_xy, ll_xy, bands=1):\n \"\"\"\n Return a 2D or 3D NumPy array subsetted to the given bounding\n extents.\n\n :param fname:\n A string containing the full file pathname to an image on\n disk.\n\n :param ul_xy:\n A tuple containing the Upper Left (x,y) co-ordinate pair\n in real world (map) co-ordinates. Co-ordinate pairs can be\n (longitude, latitude) or (eastings, northings), but they must\n be of the same reference as the image of interest.\n\n :param ur_xy:\n A tuple containing the Upper Right (x,y) co-ordinate pair\n in real world (map) co-ordinates. Co-ordinate pairs can be\n (longitude, latitude) or (eastings, northings), but they must\n be of the same reference as the image of interest.\n\n :param lr_xy:\n A tuple containing the Lower Right (x,y) co-ordinate pair\n in real world (map) co-ordinates. Co-ordinate pairs can be\n (longitude, latitude) or (eastings, northings), but they must\n be of the same reference as the image of interest.\n\n :param ll_xy:\n A tuple containing the Lower Left (x,y) co-ordinate pair\n in real world (map) co-ordinates. Co-ordinate pairs can be\n (longitude, latitude) or (eastings, northings), but they must\n be of the same reference as the image of interest.\n\n :param bands:\n Can be an integer of list of integers representing the band(s)\n to be read from disk. If bands is a list, then the returned\n subset will be 3D, otherwise the subset will be strictly 2D.\n\n :return:\n A tuple of 3 elements:\n\n * 1. 2D or 3D NumPy array containing the image subset.\n * 2. A list of length 6 containing the GDAL geotransform.\n * 3. A WKT formatted string representing the co-ordinate\n reference system (projection).\n\n :additional notes:\n The ending array co-ordinates are increased by +1,\n i.e. xend = 270 + 1\n to account for Python's [inclusive, exclusive) index notation.\n \"\"\"\n if isinstance(fname, h5py.Dataset):\n geobox = GriddedGeoBox.from_dataset(fname)\n prj = fname.attrs['crs_wkt']\n else:\n # Open the file\n with rasterio.open(fname) as src:\n\n # Get the inverse transform of the affine co-ordinate reference\n geobox = GriddedGeoBox.from_dataset(src)\n prj = src.crs.wkt # rasterio returns a unicode\n\n inv = ~geobox.transform\n rows, cols = geobox.shape\n\n # Convert each map co-ordinate to image/array co-ordinates\n img_ul_x, img_ul_y = [int(v) for v in inv * ul_xy]\n img_ur_x, img_ur_y = [int(v) for v in inv * ur_xy]\n img_lr_x, img_lr_y = [int(v) for v in inv * lr_xy]\n img_ll_x, img_ll_y = [int(v) for v in inv * ll_xy]\n\n # Calculate the min and max array extents\n # The ending array extents have +1 to account for Python's\n # [inclusive, exclusive) index notation.\n xstart = min(img_ul_x, img_ll_x)\n ystart = min(img_ul_y, img_ur_y)\n xend = max(img_ur_x, img_lr_x) + 1\n yend = max(img_ll_y, img_lr_y) + 1\n\n # Check for out of bounds\n if (((xstart < 0) or (ystart < 0)) or\n ((xend -1 > cols) or (yend -1 > rows))):\n\n msg = (\"Error! Attempt to read a subset that is outside of the\"\n \"image domain. Index: ({ys}, {ye}), ({xs}, {xe}))\")\n msg = msg.format(ys=ystart, ye=yend, xs=xstart, xe=xend)\n raise IndexError(msg)\n\n if isinstance(fname, h5py.Dataset):\n subs = fname[ystart:yend, xstart:xend]\n else:\n with rasterio.open(fname) as src:\n subs = src.read(bands, window=((ystart, yend), (xstart, xend)))\n\n # Get the new UL co-ordinates of the array\n ul_x, ul_y = geobox.transform * (xstart, ystart)\n\n geobox_subs = GriddedGeoBox(shape=subs.shape, origin=(ul_x, ul_y),\n pixelsize=geobox.pixelsize, crs=prj)\n\n return (subs, geobox_subs)\n\n\ndef reproject_file_to_array(src_filename, src_band=1, dst_geobox=None,\n resampling=Resampling.nearest):\n \"\"\"\n Given an image on file, reproject to the desired coordinate\n reference system.\n\n :param src_filename:\n A string containing the full file path name to the source\n image on disk.\n\n :param src_band:\n An integer representing the band number to be reprojected.\n Default is 1, the 1st band.\n\n :param dst_geobox:\n An instance of a GriddedGeoBox object containing the\n destination parameters such as origin, affine, projection,\n and array dimensions.\n\n :param resampling:\n An integer representing the resampling method to be used.\n check rasterio.warp.RESMPLING for more details.\n Default is 0, nearest neighbour resampling.\n\n :return:\n A NumPy array containing the reprojected result.\n \"\"\"\n\n if not isinstance(dst_geobox, GriddedGeoBox):\n msg = 'dst_geobox must be an instance of a GriddedGeoBox! Type: {}'\n msg = msg.format(type(dst_geobox))\n raise TypeError(msg)\n\n with rasterio.open(src_filename) as src:\n # Define a rasterio band\n rio_band = rasterio.band(src, src_band)\n\n # Define the output NumPy array\n dst_arr = np.zeros(dst_geobox.shape, dtype=src.dtypes[0])\n\n # Get the rasterio proj4 styled dict\n prj = CRS.from_string(dst_geobox.crs.ExportToProj4())\n\n reproject(rio_band, dst_arr, dst_transform=dst_geobox.transform,\n dst_crs=prj, resampling=resampling)\n\n return dst_arr\n\n\ndef reproject_img_to_img(src_img, src_geobox, dst_geobox,\n resampling=Resampling.nearest):\n \"\"\"\n Reprojects an image/array to the desired co-ordinate reference system.\n\n :param src_img:\n A NumPy array containing the source image.\n\n :param src_geobox:\n An instance of a GriddedGeoBox object containing the\n source parameters such as origin, affine, projection.\n\n :param dst_geobox:\n An instance of a GriddedGeoBox object containing the\n destination parameters such as origin, affine, projection,\n and array dimensions.\n\n :param resampling:\n An integer representing the resampling method to be used.\n check rasterio.warp.RESMPLING for more details.\n Default is 0, nearest neighbour resampling.\n\n :return:\n A NumPy array containing the reprojected result.\n \"\"\"\n\n if not isinstance(dst_geobox, GriddedGeoBox):\n msg = 'dst_geobox must be an instance of a GriddedGeoBox! Type: {}'\n msg = msg.format(type(dst_geobox))\n raise TypeError(msg)\n\n if not isinstance(src_geobox, GriddedGeoBox):\n msg = 'src_geobox must be an instance of a GriddedGeoBox! Type: {}'\n msg = msg.format(type(src_geobox))\n raise TypeError(msg)\n\n # Get the source and destination projections in Proj4 styled dicts\n src_prj = CRS.from_string(src_geobox.crs.ExportToProj4())\n dst_prj = CRS.from_string(dst_geobox.crs.ExportToProj4())\n\n # Get the source and destination transforms\n src_trans = src_geobox.transform\n dst_trans = dst_geobox.transform\n\n # Define the output NumPy array\n dst_arr = np.zeros(dst_geobox.shape, dtype=src_img.dtype)\n\n reproject(src_img, dst_arr, src_transform=src_trans,\n src_crs=src_prj, dst_transform=dst_trans, dst_crs=dst_prj,\n resampling=resampling)\n\n return dst_arr\n\n\ndef as_array(array, dtype, transpose=False):\n \"\"\"\n Given an array and dtype, array will be converted to dtype if\n and only if array.dtype != dtype. If transpose is set to True\n then array will be transposed before returning.\n\n :param array:\n A NumPy array.\n\n :param dtype:\n The type to return the array as.\n :type dtype:\n A NumPy data type (e.g. ``numpy.float32``).\n\n :param transpose:\n If set then array will be transposed before returning.\n Useful for passing arrays into Fortran routiines. Default is\n False.\n :type transpose:\n Bool.\n\n :return:\n A :py:class:`numpy.ndarry` of type ``dtype`` with the same\n dimensions as array.\n \"\"\"\n if array.dtype != dtype:\n if transpose:\n return array.astype(dtype).transpose()\n return array.astype(dtype)\n if transpose:\n return array.transpose()\n return array\n" ]	[ [ "numpy.uint8", "numpy.zeros", "numpy.empty" ] ]
mrdbarros/csgo_analyze	[ "a4d7487bd56a14a99dc762920965060a5a43fa15" ]	[ "models.py" ]	[ "import data_loading\nimport torch\n\n\n\n\n\ndef emb_sz_rule(n_cat):\n \"Rule of thumb to pick embedding size corresponding to `n_cat`\"\n return min(600, round(1.6 * n_cat ** 0.56))\n\n\nclass LinBnDrop(torch.nn.Sequential):\n \"Module grouping `BatchNorm1d`, `Dropout` and `Linear` layers\"\n\n def __init__(self, n_in, n_out, bn=True, p=0., act=None, lin_first=False):\n layers = [torch.nn.BatchNorm1d(n_in)] if bn else []\n if p != 0: layers.append(torch.nn.Dropout(p))\n lin = [torch.nn.Linear(n_in, n_out, bias=not bn)]\n if act is not None: lin.append(act)\n layers = lin + layers if lin_first else layers + lin\n super().__init__(layers)\n\n\n\nclass TabularModelCustom(torch.nn.Module):\n \"Basic model for tabular data.\"\n\n def __init__(self, category_list, class_groups_sizes, n_cont, layers, ps=None, embed_p=0.,\n use_bn=True, bn_final=True, bn_cont=True):\n\n super().__init__()\n ps = ps\n\n class_group_map = {}\n for i, cat in enumerate(category_list):\n class_group = cat[cat.rfind(\"_\") + 1:]\n class_group_index, _ = class_groups_sizes[class_group]\n if class_group_index in class_group_map:\n class_group_map[class_group_index].append(i)\n else:\n class_group_map[class_group_index] = [i]\n self.class_group_map = class_group_map\n self.embeds = torch.nn.ModuleList(\n [torch.nn.Embedding(index_ni[1], emb_sz_rule(index_ni[1])) for _, index_ni in class_groups_sizes.items() if\n index_ni[1] > 2])\n self.emb_drop = torch.nn.Dropout(embed_p)\n self.bn_cont = torch.nn.BatchNorm1d(n_cont) if bn_cont else None\n\n binary_size = sum(len(class_group_map[i]) for i in range(len(self.embeds), len(class_group_map)))\n n_emb = sum(e.embedding_dim len(class_group_map[i]) for i, e in enumerate(self.embeds)) + binary_size\n self.n_emb, self.n_cont = n_emb, n_cont\n sizes = [n_emb + n_cont] + layers\n actns = [torch.nn.ReLU(inplace=True) for _ in range(len(sizes) - 1)]\n _layers = [LinBnDrop(sizes[i], sizes[i + 1], bn=use_bn and (i != len(actns) - 1 or bn_final), p=p, act=a)\n for i, (p, a) in enumerate(zip(ps, actns))]\n\n self.layers = torch.nn.Sequential(_layers)\n\n def forward(self, x_cat, x_cont=None):\n\n if self.n_emb != 0:\n x_cat_binary = []\n for i in range(len(self.embeds), len(self.class_group_map)):\n x_cat_binary += self.class_group_map[i]\n with torch.no_grad():\n x_cat_binary = x_cat[:, x_cat_binary].float()\n x_cat_nonbinary = [torch.flatten(e(x_cat[:, self.class_group_map[i]]), start_dim=1) for i, e in\n enumerate(self.embeds)]\n x = torch.cat(x_cat_nonbinary + [x_cat_binary], 1)\n x = self.emb_drop(x)\n if self.n_cont != 0:\n if self.bn_cont is not None: x_cont = self.bn_cont(x_cont)\n x = torch.cat([x, x_cont], 1) if self.n_emb != 0 else x_cont\n return self.layers(x)\n\n\n\nclass CustomMixedModel(torch.nn.Module):\n def __init__(self, image_model, tab_model, seq_model, image_output_size, embeds_size,prepare_and_pad,max_image_batch):\n super(CustomMixedModel, self).__init__()\n self.image_model = image_model\n # embedding types are primaries, secondaries, flashbangs and binaries\n # self.classifier = TabularModel_NoCat(emb_sizes,1536, 30,[400],ps=[0.1],use_bn=False)\n self.tab_model = tab_model\n # n_emb = sum(e.embedding_dim for e in self.embeds)\n self.seq_model = seq_model\n self.classifier = torch.nn.Sequential(LinBnDrop(200 + image_output_size\n + embeds_size\n , 1, act=None, p=0.))\n self.prepare_and_pad = prepare_and_pad\n self.max_image_batch = max_image_batch\n def forward(self, input_cat, input_cont, input_image, attention_mask, train_embeds=True, train_seq_model=True):\n valid_sizes = torch.sum((attention_mask == 1), dim=1)\n if train_embeds:\n input_embed = self.forward_embeds(input_cat, input_cont, input_image,valid_sizes)\n else:\n with torch.no_grad():\n\n input_embed = self.forward_embeds(input_cat, input_cont, input_image,valid_sizes)\n\n input_embed=self.prepare_and_pad(input_embed,valid_sizes)\n\n if train_seq_model:\n\n bert_out = self.forward_seq_model(input_embed, attention_mask)\n else:\n with torch.no_grad():\n bert_out = self.forward_seq_model(input_embed, attention_mask)\n\n\n\n output = self.classifier(\n torch.cat((input_embed[range(input_embed.shape[0]), valid_sizes-1], bert_out),\n dim=1))\n # output = self.classifier(input_embed[range(input_embed.shape[0]), (input_embed.shape[1] - mask_size - 1)])\n # output = self.classifier(bert_out)\n return output\n\n def forward_embeds(self, input_cat, input_cont, input_image,valid_size):\n n_batches = (input_image.shape[0]//self.max_image_batch)+1(input_image.shape[0]%self.max_image_batch>0)\n\n tab_out = self.tab_model(input_cat,input_cont)\n image_out = torch.cat([self.image_model(input_image[iself.max_image_batch:min((i+1)self.max_image_batch,input_image.shape[0])])\n for i in range(n_batches)],dim=0)\n # comprehension to break inputs in 'n_batches' of 'self.max_image_batch' size\n input_embed = torch.cat((tab_out,image_out),dim=1)\n input_embed = torch.nn.ReLU()(input_embed)\n return input_embed\n\n def forward_seq_model(self, input_embed, attention_mask):\n # bert_out = self.seq_model(input_embed.permute((1, 0, 2)),\n # src_key_padding_mask=attention_mask).permute((1, 0, 2))[:, 0]\n bert_out = torch.mean(self.seq_model(inputs_embeds=input_embed,\n attention_mask=attention_mask)[0],dim=1)\n bert_out = torch.nn.ReLU()(bert_out)\n return bert_out\n\n\nclass CustomMixedModelSingleImage(torch.nn.Module):\n def __init__(self, image_model, tab_model, image_output_size,class_p):\n super(CustomMixedModelSingleImage, self).__init__()\n self.image_model = image_model\n # embedding types are primaries, secondaries, flashbangs and binaries\n # self.classifier = TabularModel_NoCat(emb_sizes,1536, 30,[400],ps=[0.1],use_bn=False)\n self.tab_model = tab_model\n # n_emb = sum(e.embedding_dim for e in self.embeds)\n self.classifier = torch.nn.Sequential(LinBnDrop(50 + image_output_size, 40, act=torch.nn.ReLU(), p=class_p),\n LinBnDrop(40, 1, act=None, p=class_p))\n\n def forward(self, input_cat, input_cont, input_image):\n output_tabular = self.tab_model(input_cat, input_cont)\n output_image = self.image_model(input_image)\n logits = self.classifier(torch.nn.ReLU()(torch.cat((output_tabular, output_image), dim=1)))\n\n return logits\n\n" ]	[ [ "torch.nn.Sequential", "torch.nn.Dropout", "torch.nn.BatchNorm1d", "torch.cat", "torch.sum", "torch.nn.Linear", "torch.no_grad", "torch.nn.ReLU" ] ]
tomiock/qGAN	[ "fb98a2b5286eb479665ade353efa40bd6e55dc36" ]	[ "quantumGAN/deprecated_files/discriminator_minimax.py" ]	[ "\"\"\"DISCRIMINATOR BCE\"\"\"\nimport json\nimport random\nfrom typing import Dict, List\n\nimport numpy as np\n\nfrom quantumGAN.functions import minimax_derivative_fake, minimax_derivative_real, sigmoid, \\\n\tsigmoid_prime\n\n\ndef load(filename):\n\tf = open(filename, \"r\")\n\tdata = json.load(f)\n\tf.close()\n\t# cost = getattr(sys.modules[__name__], data[\"cost\"])\n\tnet = ClassicalDiscriminatorMINIMAX(None, None, data[\"sizes\"], data[\"loss\"])\n\tnet.weights = [np.array(w) for w in data[\"weights\"]]\n\tnet.biases = [np.array(b) for b in data[\"biases\"]]\n\treturn net\n\n\nclass ClassicalDiscriminatorMINIMAX:\n\n\tdef __init__(self,\n\t training_data: List or None,\n\t mini_batch_size: int or None,\n\t sizes: List[int],\n\t loss_BCE: bool) -> None:\n\n\t\tself.training_data = training_data\n\t\tself.mini_batch_size: int = mini_batch_size\n\t\tself.num_layers = len(sizes)\n\t\tself.sizes = sizes\n\t\tself.loss_BCE = loss_BCE\n\t\tself.data_loss = {\"real\": [],\n\t\t \"fake\": []}\n\t\tself.ret: Dict[str, any] = {\"loss\": [],\n\t\t \"label real\": [],\n\t\t \"label fake\": [],\n\t\t \"label fake time\": [],\n\t\t \"label real time\": []}\n\t\tself.biases = [np.random.randn(y, ) for y in sizes[1:]]\n\t\tself.weights = [np.random.randn(y, x)\n\t\t for x, y in zip(sizes[:-1], sizes[1:])]\n\n\tdef feedforward(self, a):\n\t\t\"\"\"Return the output of the network if ``a`` is input.\"\"\"\n\t\tfor b, w in zip(self.biases, self.weights):\n\t\t\ta = sigmoid(np.dot(w, a) + b)\n\t\treturn a\n\n\tdef predict(self, x):\n\t\t# feedforward\n\t\tactivation = x\n\t\tzs = [] # list to store all the z vectors, layer by layer\n\t\tfor b, w in zip(self.biases, self.weights):\n\t\t\tz = np.dot(w, activation) + b\n\t\t\tzs.append(z)\n\t\t\tactivation = sigmoid(z)\n\t\treturn activation\n\n\tdef evaluate(self, test_data):\n\n\t\ttest_results = [(np.argmax(self.feedforward(x)), y)\n\t\t for (x, y) in test_data]\n\t\treturn sum(int(x == y) for (x, y) in test_results)\n\n\tdef save(self, filename):\n\t\t\"\"\"Save the neural network to the file ``filename``.\"\"\"\n\t\tdata = {\"sizes\": self.sizes,\n\t\t \"weights\": [w.tolist() for w in self.weights],\n\t\t \"biases\": [b.tolist() for b in self.biases],\n\t\t \"loss\": self.loss_BCE # ,\n\t\t # \"cost\": str(self..__name__)\n\t\t }\n\t\tf = open(filename, \"w\")\n\t\tjson.dump(data, f)\n\t\tf.close()\n\n\tdef forwardprop(self, x: np.ndarray):\n\t\tactivation = x\n\t\tactivations = [x] # list to store all the activations, layer by layer\n\t\tzs = [] # list to store all the z vectors, layer by layer\n\t\tfor b, w in zip(self.biases, self.weights):\n\t\t\tz = np.dot(w, activation) + b\n\t\t\tzs.append(z)\n\t\t\tactivation = sigmoid(z)\n\t\t\tactivations.append(activation)\n\t\treturn activation, activations, zs\n\n\tdef backprop(self, real_image, fake_image, is_real):\n\t\t\"\"\"Return a tuple ``(nabla_b, nabla_w)`` representing the\n gradient for the cost function C_x. ``nabla_b`` and\n ``nabla_w`` are layer-by-layer lists of numpy arrays, similar\n to ``self.biases`` and ``self.weights``.\"\"\"\n\t\tnabla_b = [np.zeros(b.shape) for b in self.biases]\n\t\tnabla_w = [np.zeros(w.shape) for w in self.weights]\n\n\t\t# feedforward and back error calculation depending on type of image\n\t\tactivation_real, activations_real, zs_real = self.forwardprop(real_image)\n\t\tactivation_fake, activations_fake, zs_fake = self.forwardprop(fake_image)\n\n\t\tif is_real:\n\t\t\tdelta = minimax_derivative_real(activations_real[-1]) * sigmoid_prime(zs_real[-1])\n\t\t\tactivations, zs = activations_real, zs_real\n\t\telse:\n\t\t\tdelta = minimax_derivative_fake(activations_fake[-1]) * sigmoid_prime(zs_fake[-1])\n\t\t\tactivations, zs = activations_fake, zs_fake\n\n\t\t# backward pass\n\t\tnabla_b[-1] = delta\n\t\tnabla_w[-1] = np.dot(delta, activations[-2].reshape(1, activations[-2].shape[0]))\n\n\t\tfor l in range(2, self.num_layers):\n\t\t\tz = zs[-l]\n\t\t\tdelta = np.dot(self.weights[-l + 1].transpose(), delta) * sigmoid_prime(z)\n\t\t\tnabla_b[-l] = delta\n\t\t\tnabla_w[-l] = np.dot(delta.reshape(delta.shape[0], 1),\n\t\t\t activations[-l - 1].reshape(1, activations[-l - 1].shape[0]))\n\t\treturn nabla_b, nabla_w, activations[-1]\n\n\tdef train_mini_batch(self, mini_batch, learning_rate):\n\t\tglobal label_real, label_fake\n\t\tnabla_b = [np.zeros(b.shape) for b in self.biases]\n\t\tnabla_w = [np.zeros(w.shape) for w in self.weights]\n\n\t\tfor real_image, fake_image in mini_batch:\n\t\t\tdelta_nabla_b, delta_nabla_w, label_real = self.backprop(real_image, fake_image, True)\n\t\t\tnabla_b = [nb + dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]\n\t\t\tnabla_w = [nw + dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]\n\n\t\t\tdelta_nabla_b, delta_nabla_w, label_fake = self.backprop(real_image, fake_image, False)\n\t\t\tnabla_b = [nb + dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]\n\t\t\tnabla_w = [nw + dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]\n\n\t\t# gradient descent\n\t\t# nabla_w and nabla_b are multiplied by the learning rate\n\t\t# and taken the mean of (dividing by the mini batch size)\n\t\tself.weights = [w - (learning_rate / len(mini_batch)) * nw\n\t\t for w, nw in zip(self.weights, nabla_w)]\n\t\tself.biases = [b - (learning_rate / len(mini_batch)) * nb\n\t\t for b, nb in zip(self.biases, nabla_b)]\n\n\tdef create_mini_batches(self):\n\t\tn = len(self.training_data)\n\t\trandom.shuffle(self.training_data)\n\t\tmini_batches = [\n\t\t\tself.training_data[k:k + self.mini_batch_size]\n\t\t\tfor k in range(0, n, self.mini_batch_size)]\n\t\treturn [mini_batches[0]]\n" ]	[ [ "numpy.dot", "numpy.array", "numpy.random.randn", "numpy.zeros" ] ]
litosly/RankingOptimizationApprochtoLLC	[ "b6b79fb1364fcc481aa84093a8e8399966b19d02" ]	[ "models/llc_score.py" ]	[ "from prediction.predictor import predict_scores, predict_vector\nfrom sklearn.linear_model import LinearRegression\nfrom utils.critique import LP1SimplifiedOptimize\nfrom utils.keyphrase_selection import \n\nimport numpy as np\nfrom tqdm import tqdm\n\n\nclass LP1Simplified(object):\n def __init__(self, keyphrase_freq, item_keyphrase_freq, row, matrix_Train, matrix_Test, test_users,\n target_ranks, num_items_sampled, num_keyphrases, df,\n max_iteration_threshold, keyphrase_popularity, dataset_name,\n model, parameters_row, keyphrase_selection_method, topk=None, lamb = None,*unused):\n self.keyphrase_freq = keyphrase_freq\n self.item_keyphrase_freq = item_keyphrase_freq.T\n self.row = row\n self.matrix_Train = matrix_Train\n self.num_users, self.num_items = matrix_Train.shape\n self.matrix_Test = matrix_Test\n self.test_users = test_users\n self.target_ranks = target_ranks\n self.num_items_sampled = num_items_sampled\n self.num_keyphrases = num_keyphrases\n self.df = df\n self.max_iteration_threshold = max_iteration_threshold\n self.keyphrase_popularity = keyphrase_popularity\n self.dataset_name = dataset_name\n self.model = model\n self.parameters_row = parameters_row\n\n self.keyphrase_selection_method = keyphrase_selection_method\n self.max_wanted_keyphrase = max_iteration_threshold # Set diff length to be equal to max_iteration_threshold\n self.topk = topk\n def start_critiquing(self):\n self.get_initial_predictions()\n for user in tqdm(self.test_users):\n # User id starts from 0\n self.row['user_id'] = user\n\n # The iteration will stop if the wanted item is in top n\n for target_rank in self.target_ranks:\n self.row['target_rank'] = target_rank\n # Pick wanted items in test items\n candidate_items = self.matrix_Test[user].nonzero()[1]\n train_items = self.matrix_Train[user].nonzero()[1]\n wanted_items = np.setdiff1d(candidate_items, train_items)\n\n for item in wanted_items:\n # Item id starts from 0\n self.row['item_id'] = item\n # Set the wanted item's initial rank as None\n self.row['item_rank'] = None\n # Set the wanted item's initial prediction score as None\n self.row['item_score'] = None\n\n # Get the item's existing keyphrases\n item_keyphrases = self.item_keyphrase_freq[item].nonzero()[0]\n # Get keyphrases that don't belong to the item (we can critique)\n remaining_keyphrases = np.setdiff1d(range(self.num_keyphrases), item_keyphrases)\n# print(\"The number of remaining_keyphrases is {}. remaining_keyphrases are: {}\".format(len(remaining_keyphrases), remaining_keyphrases))\n self.row['num_existing_keyphrases'] = len(remaining_keyphrases)\n\n if self.keyphrase_selection_method == \"diff\":\n # For keyphrase selection method 'diff' \n target_keyphrase_freq = get_item_keyphrase_freq(self.item_keyphrase_freq,item = item)\n # diff_keyphrase_freq = top_recommended_keyphrase_freq - target_keyphrase_freq\n # remaining_keyphrases = np.argsort(np.ravel(diff_keyphrase_freq))[::-1][:self.max_wanted_keyphrase]\n self.row['num_existing_keyphrases'] = self.max_iteration_threshold\n\n\n if len(remaining_keyphrases) == 0:\n break\n self.row['iteration'] = 0\n self.row['critiqued_keyphrase'] = None\n self.row['result'] = None\n self.df = self.df.append(self.row, ignore_index=True)\n\n query = []\n affected_items = np.array([])\n\n\n for iteration in range(self.max_iteration_threshold):\n self.row['iteration'] = iteration + 1\n\n if self.keyphrase_selection_method == \"pop\":\n # Always critique the most popular keyphrase\n critiqued_keyphrase = remaining_keyphrases[np.argmax(self.keyphrase_popularity[remaining_keyphrases])]\n elif self.keyphrase_selection_method == \"random\":\n # Randomly critique a remaining keyphrase\n critiqued_keyphrase = np.random.choice(remaining_keyphrases, size=1, replace=False)[0]\n elif self.keyphrase_selection_method == \"diff\":\n if iteration == 0:\n initial_prediction_items = predict_vector(rating_vector=self.prediction_scores[user],\n train_vector=self.matrix_Train[user],\n remove_train=True)\n top_recommended_keyphrase_freq = get_item_keyphrase_freq(self.item_keyphrase_freq,item = initial_prediction_items[0])\n self.row[\"Recommended Item\"] = initial_prediction_items[0]\n # self.row['Recommended Item Name'] = get_restaurant_name(self.df_train, self.business_df,initial_prediction_items[0])\n else:\n top_recommended_keyphrase_freq = get_item_keyphrase_freq(self.item_keyphrase_freq,item = prediction_items[0])\n self.row[\"Recommended Item\"] = prediction_items[0]\n # self.row['Recommended Item Name'] = get_restaurant_name(self.df_train, self.business_df,prediction_items[0])\n diff_keyphrase_freq = top_recommended_keyphrase_freq - target_keyphrase_freq\n remaining_keyphrases = np.argsort(np.ravel(diff_keyphrase_freq))[::-1][:self.max_wanted_keyphrase]\n critiqued_keyphrase = remaining_keyphrases[0]\n\n self.row['critiqued_keyphrase'] = critiqued_keyphrase\n query.append(critiqued_keyphrase)\n\n # Get affected items (items have critiqued keyphrase)\n current_affected_items = self.item_keyphrase_freq[:, critiqued_keyphrase].nonzero()[0]\n affected_items = np.unique(np.concatenate((affected_items, current_affected_items))).astype(int)\n unaffected_items = np.setdiff1d(range(self.num_items), affected_items)\n\n if iteration == 0:\n prediction_items = predict_vector(rating_vector=self.prediction_scores[user],\n train_vector=self.matrix_Train[user],\n remove_train=True)\n\n affected_items_mask = np.in1d(prediction_items, affected_items)\n affected_items_index_rank = np.where(affected_items_mask == True)\n unaffected_items_index_rank = np.where(affected_items_mask == False)\n\n import copy\n top_k = int(self.topk)\n prediction_scores_u, lambdas = LP1SimplifiedOptimize(initial_prediction_u=self.prediction_scores[user],\n keyphrase_freq=copy.deepcopy(self.keyphrase_freq),\n affected_items=np.intersect1d(affected_items, prediction_items[affected_items_index_rank[0][:top_k]]),\n unaffected_items=np.intersect1d(unaffected_items, prediction_items[unaffected_items_index_rank[0][:top_k]]),\n num_keyphrases=self.num_keyphrases,\n query=query,\n test_user=user,\n item_latent=self.Y,\n reg=self.reg)\n\n self.row['lambda'] = lambdas\n prediction_items = predict_vector(rating_vector=prediction_scores_u,\n train_vector=self.matrix_Train[user],\n remove_train=True)\n recommended_items = prediction_items\n\n # Current item rank\n item_rank = np.where(recommended_items == item)[0][0]\n\n self.row['item_rank'] = item_rank\n self.row['item_score'] = prediction_scores_u[item]\n\n if item_rank + 1 <= target_rank:\n # Items is ranked within target rank\n self.row['result'] = 'successful'\n self.df = self.df.append(self.row, ignore_index=True)\n break\n else:\n remaining_keyphrases = np.setdiff1d(remaining_keyphrases, critiqued_keyphrase)\n # Continue if more keyphrases and iterations remained\n if len(remaining_keyphrases) > 0 and self.row['iteration'] < self.max_iteration_threshold:\n self.row['result'] = None\n self.df = self.df.append(self.row, ignore_index=True)\n else:\n # Otherwise, mark fail\n self.row['result'] = 'fail'\n self.df = self.df.append(self.row, ignore_index=True)\n break\n return self.df\n\n\n def get_initial_predictions(self):\n self.RQ, Yt, Bias = self.model(self.matrix_Train,\n iteration=self.parameters_row['iter'].values[0],\n lamb=self.parameters_row['lambda'].values[0],\n rank=self.parameters_row['rank'].values[0])\n self.Y = Yt.T\n\n self.reg = LinearRegression().fit(self.keyphrase_freq, self.RQ)\n\n self.prediction_scores = predict_scores(matrix_U=self.RQ,\n matrix_V=self.Y,\n bias=Bias)\n\n" ]	[ [ "numpy.random.choice", "numpy.in1d", "numpy.setdiff1d", "numpy.concatenate", "numpy.intersect1d", "numpy.argmax", "sklearn.linear_model.LinearRegression", "numpy.ravel", "numpy.array", "numpy.where" ] ]
MiningMyBusiness/SketchyExperiments	[ "11f3baee63a984501b9707aa58420540b19db59f" ]	[ "Autoencoding/save32by32ForAll.py" ]	[ "## Name: Save 32 by 32 image vector\r\n## Description: Reads in the matrix representation of the images\r\n## for each class and resizes each image from 256 by 256\r\n## to 32 by 32 and then converts it to a vector with\r\n## 1024 elements (3232). A stack of these vectors (matrix)\r\n## is then saved in the class directory.\r\n## NOTE: This code uses the output from PNGtoNumpy.py\r\n## Author: Kiran Bhattacharyya\r\n\r\nimport glob\r\nimport numpy as np\r\nimport matplotlib.pyplot as plt\r\nimport cv2\r\n\r\n# location of the data\r\ndataLoc = '256X256/sketch/tx_000100000000'\r\n\r\nallFolders = glob.glob(dataLoc + '/') # get all folders with data\r\n\r\nnewSize = 32\r\n\r\ndef readImgAndResize(folderName, multi, newSize):\r\n imgStack_mat = np.load(folder + '/matStack.npy')\r\n num_of_images = imgStack_mat.shape[2]\r\n smallerImgs = np.zeros((num_of_images, newSize*2))\r\n for i in range(0, int(multinum_of_images)):\r\n smallerImgs[i, :] = resizeAndVectorize(imgStack_mat[:, :, i], newSize)\r\n return smallerImgs\r\n\r\ndef resizeAndVectorize(thisImg, newSize):\r\n resized = cv2.resize(thisImg, (newSize, newSize),\r\n interpolation=cv2.INTER_AREA)\r\n resized = np.reshape(resized, newSize**2)\r\n resized = resized - np.min(resized)\r\n resized = resized/np.max(resized)\r\n return resized\r\n\r\n\r\nfolderCount = 0\r\niter = 0\r\nmulti = 1.0\r\nallData = []\r\nfor folder in allFolders:\r\n print('Folder ' + str(folderCount+1) + ' of ' + str(len(allFolders)) + '.')\r\n smallerImgs = readImgAndResize(folder, multi, newSize)\r\n np.save(folder + '/32by32vecStack.npy', smallerImgs)\r\n folderCount += 1\r\n" ]	[ [ "numpy.min", "numpy.reshape", "numpy.save", "numpy.max", "numpy.load", "numpy.zeros" ] ]
mwanakijiji/rrlfe2	[ "4a822bb499bd0af4543f8b34d9322e812a5a3d2c" ]	[ "tests/test_scrape_ew_and_errew.py" ]	[ "import matplotlib\nmatplotlib.use('Agg')\n\nimport sys, os\nfrom configparser import ConfigParser, ExtendedInterpolation\nimport pandas as pd\nimport astropy\n\ncurrent_dir = os.path.dirname(__file__)\ntarget_dir = os.path.abspath(os.path.join(current_dir, \"../\"))\nsys.path.insert(0, target_dir)\n\n# import more things with changed system path\nfrom modules import \nfrom modules import scrape_ew_and_errew\nfrom conf import \nimport numpy as np\nimport glob\n\n# configuration data for reduction\nconfig_red = ConfigParser(interpolation=ExtendedInterpolation()) # for parsing values in .init file\n# config for reduction to find a, b, c, d\nconfig_red.read(os.path.join(os.path.dirname(__file__), '../conf', 'config_red.ini'))\n\n\ndef test_line_order_check():\n\n dummy_lines = [3933.660,3970.075,4101.7100,4340.472,4861.290]\n test_num_glitches_0 = scrape_ew_and_errew.line_order_check(dummy_lines)\n dummy_lines[1] = 3990.\n dummy_lines[3] = 4320.\n test_num_glitches_1 = scrape_ew_and_errew.line_order_check(dummy_lines)\n dummy_lines[0] = 3913.\n dummy_lines[2] = 4121.\n dummy_lines[4] = 4881.\n test_num_glitches_2 = scrape_ew_and_errew.line_order_check(dummy_lines)\n\n # assert glitches is boolean\n assert test_num_glitches_0 == 0\n assert test_num_glitches_1 == 1\n assert test_num_glitches_2 == 1\n\n\ndef test_Scraper():\n\n '''\n write_dir_test = config_red[\"data_dirs\"][\"TEST_DIR_BIN\"]\n robo_dir = config_red[\"sys_dirs\"][\"DIR_ROBO\"]\n file_names_test = glob.glob(config_red[\"data_dirs\"][\"TEST_DIR_SRC\"] + \"spec_norm_final/*\")\n '''\n\n # instantiate\n scraper_instance = scrape_ew_and_errew.Scraper(subdir = config_red[\"data_dirs\"][\"TEST_DIR_ROBO_OUTPUT\"],\n file_scraped_info = config_red[\"data_dirs\"][\"TEST_DIR_BIN\"]+\"scraper_output/\"+config_red[\"file_names\"][\"SCRAPED_EW_ALL_DATA\"])\n\n\n # try a single instance; does it work?\n # note the writing of files is not directly tested here\n function_state = True\n try:\n test = scraper_instance()\n except Exception as e:\n # e contains printable attributes of exception object\n function_state = False\n\n # assert that instantiation worked\n assert function_state\n\n # make sure lines are really being identified correctly\n assert np.allclose(test.where(test[\"line_name\"]==\"CaIIK\").dropna()[\"wavel_found_center\"],3933.660, atol=2.)\n assert np.allclose(test.where(test[\"line_name\"]==\"Heps\").dropna()[\"wavel_found_center\"],3970.075, atol=2.)\n assert np.allclose(test.where(test[\"line_name\"]==\"Hdel\").dropna()[\"wavel_found_center\"],4101.710, atol=2.)\n assert np.allclose(test.where(test[\"line_name\"]==\"Hgam\").dropna()[\"wavel_found_center\"],4340.472, atol=2.)\n assert np.allclose(test.where(test[\"line_name\"]==\"Hbet\").dropna()[\"wavel_found_center\"],4861.290, atol=2.)\n\n # only 2 of the 3 spectra should have been scraped, because one should have\n # triggered a parsing errors\n assert len(test.where(test[\"line_name\"]==\"CaIIK\").dropna()) == 2\n\n\n\ndef test_quality_check():\n\n data_out_test = scrape_ew_and_errew.quality_check(\n read_in_filename = config_red[\"data_dirs\"][\"TEST_DIR_BIN\"]+\"scraper_output/\"+config_red[\"file_names\"][\"TEST_SCRAPED_EW_ALL_DATA\"],\n write_out_filename = config_red[\"data_dirs\"][\"TEST_DIR_BIN\"]+\"scraper_output/\"+config_red[\"file_names\"][\"TEST_SCRAPED_EW_DATA_GOOD_ONLY\"])\n\n # lots of checks of data types\n # note this uses .iloc[0] instead of [0], because bad rows with index 0 may\n # have been removed\n assert isinstance(data_out_test[\"wavel_stated_center\"].iloc[0],np.float64)\n assert isinstance(data_out_test[\"wavel_found_center\"].iloc[0],np.float64)\n assert isinstance(data_out_test[\"gaussianSigma\"].iloc[0],np.float64)\n assert isinstance(data_out_test[\"gaussianAmp\"].iloc[0],np.float64)\n assert isinstance(data_out_test[\"uncertaintyMu\"].iloc[0],np.float64)\n assert isinstance(data_out_test[\"uncertaintySigma\"].iloc[0],np.float64)\n assert isinstance(data_out_test[\"uncertaintyAmp\"].iloc[0],np.float64)\n assert isinstance(data_out_test[\"priorMu\"].iloc[0],np.float64)\n assert isinstance(data_out_test[\"priorSigma\"].iloc[0],np.float64)\n assert isinstance(data_out_test[\"priorAmp\"].iloc[0],np.float64)\n assert isinstance(data_out_test[\"EQW\"].iloc[0],np.float64)\n assert isinstance(data_out_test[\"uncertaintyEQW\"].iloc[0],np.float64)\n assert isinstance(data_out_test[\"chiSqr\"].iloc[0],np.float64)\n assert isinstance(data_out_test[\"flags\"].iloc[0],str)\n assert isinstance(data_out_test[\"blendGroup\"].iloc[0],np.int64)\n assert isinstance(data_out_test[\"line_name\"].iloc[0],str)\n assert isinstance(data_out_test[\"robolines_file_name\"].iloc[0],str)\n assert isinstance(data_out_test[\"realization_spec_file_name\"].iloc[0],str)\n assert isinstance(data_out_test[\"quality\"].iloc[0],str)\n\ndef test_stack_spectra():\n\n print(\"input list\")\n print(config_red[\"data_dirs\"][\"TEST_DIR_SRC\"] + \"test_input_file_list.list\")\n print(\"read in file name\")\n\n data_stacked_test = scrape_ew_and_errew.stack_spectra(\n read_in_filename = config_red[\"data_dirs\"][\"TEST_DIR_BIN\"]+\"scraper_output/\"+config_red[\"file_names\"][\"TEST_SCRAPED_EW_DATA_GOOD_ONLY\"],\n write_out_filename = config_red[\"data_dirs\"][\"TEST_DIR_BIN\"]+\"scraper_output/\"+config_red[\"file_names\"][\"TEST_RESTACKED_EW_DATA_GOOD_ONLY\"],\n input_list = config_red[\"data_dirs\"][\"TEST_DIR_SRC\"] + \"test_input_file_list.list\")\n\n print(\"data_stacked\")\n print(data_stacked_test.keys())\n\n # lots of checks of data types\n # note this uses .iloc[0] instead of [0], because bad rows with index 0 may\n # have been removed\n\n assert isinstance(data_stacked_test[\"realization_spec_file_name\"].iloc[0],str)\n assert isinstance(data_stacked_test[\"orig_spec_file_name\"].iloc[0],str)\n assert isinstance(data_stacked_test[\"EW_Hbeta\"].iloc[0],np.float64)\n assert isinstance(data_stacked_test[\"err_EW_Hbeta_from_robo\"].iloc[0],np.float64)\n assert isinstance(data_stacked_test[\"EW_Hdelta\"].iloc[0],np.float64)\n assert isinstance(data_stacked_test[\"err_EW_Hdelta_from_robo\"].iloc[0],np.float64)\n assert isinstance(data_stacked_test[\"EW_Hgamma\"].iloc[0],np.float64)\n assert isinstance(data_stacked_test[\"err_EW_Hgamma_from_robo\"].iloc[0],np.float64)\n assert isinstance(data_stacked_test[\"EW_Heps\"].iloc[0],np.float64)\n assert isinstance(data_stacked_test[\"err_EW_Heps_from_robo\"].iloc[0],np.float64)\n assert isinstance(data_stacked_test[\"EW_CaIIK\"].iloc[0],np.float64)\n assert isinstance(data_stacked_test[\"err_EW_CaIIK_from_robo\"].iloc[0],np.float64)\n\n\ndef test_generate_net_balmer():\n ## ## CONTINUE HERE; FINISH THIS TEST\n\n # generate the fake data: H_del =\n\n params_data, data_net_balmer_test = scrape_ew_and_errew.generate_net_balmer(\n read_in_filename = config_red[\"data_dirs\"][\"TEST_DIR_BIN\"]+\"scraper_output/test_stacked_data_pre_net_balmer_calc.csv\",\n write_out_filename = config_red[\"data_dirs\"][\"TEST_DIR_BIN\"]+\"scraper_output/test_stacked_data_post_net_balmer_calc.csv\")\n\n # is the Balmer line a true element wise average?\n\n #assert np.array(data_net_balmer_test[\"EW_Balmer\"]) == np.mean([data_net_balmer_test[\"EW_Hgamma\"],data_net_balmer_test[\"EW_Hdelta\"]], axis=0)\n '''\n # check data type of newly-added data\n assert isinstance(data_net_balmer_test[\"EW_Balmer\"].iloc[0],np.float64)\n assert isinstance(data_net_balmer_test[\"err_EW_Balmer_based_Robo\"].iloc[0],np.float64)\n '''\n assert 1<2\n\n\ndef test_generate_addl_ew_errors():\n # placeholder for now, until more decisions about how to calculate EW errors\n\n test_df_postbalmer_errors = scrape_ew_and_errew.generate_addl_ew_errors(read_in_filename=config_red[\"data_dirs\"][\"TEST_DIR_SRC\"]+config_red[\"file_names\"][\"TEST_RESTACKED_EW_DATA_W_NET_BALMER\"],\n write_out_filename=config_red[\"data_dirs\"][\"TEST_DIR_BIN\"]+config_red[\"file_names\"][\"TEST_RESTACKED_EW_DATA_W_NET_BALMER_ERRORS\"])\n\n # loop through batches of rows corresponding to an individual spectrum, and\n # make sure the errors are consistent and the value expected\n array_1 = test_df_postbalmer_errors[\"err_EW_Balmer_based_noise_churning\"].where(test_df_postbalmer_errors[\"orig_spec_file_name\"]==\"575020m10.smo\").dropna().values\n array_2 = test_df_postbalmer_errors[\"err_EW_Balmer_based_noise_churning\"].where(test_df_postbalmer_errors[\"orig_spec_file_name\"]==\"575020m15.smo\").dropna().values\n array_3 = test_df_postbalmer_errors[\"err_EW_Balmer_based_noise_churning\"].where(test_df_postbalmer_errors[\"orig_spec_file_name\"]==\"575020m20.smo\").dropna().values\n # check that error values are same\n assert np.all(array_1)\n assert np.all(array_2)\n assert np.all(array_3)\n # check that one value has expected value\n assert round(array_1[0], 3) == 0.023\n assert round(array_2[0], 3) == 0.020\n assert round(array_3[0], 3) == 0.048\n\n # in unusual case where collapsing the noise-churned spectra is not desired\n test_df_postbalmer_errors_nogrouping = scrape_ew_and_errew.generate_addl_ew_errors(read_in_filename=config_red[\"data_dirs\"][\"TEST_DIR_SRC\"]+config_red[\"file_names\"][\"TEST_RESTACKED_EW_DATA_W_NET_BALMER\"],\n write_out_filename=config_red[\"data_dirs\"][\"TEST_DIR_BIN\"]+config_red[\"file_names\"][\"TEST_RESTACKED_EW_DATA_W_NET_BALMER_ERRORS\"],\n groupby_parent = False)\n\n array_1_children = test_df_postbalmer_errors_nogrouping.where(test_df_postbalmer_errors[\"orig_spec_file_name\"]==\"575020m10.smo\").dropna()\n\n # there are 40 rows for each parent spectrum, and the Balmer EW values are different in each\n assert len(array_1_children) == 20\n assert np.std(array_1_children[\"EW_Balmer\"]) > 0\n\n\ndef test_add_synthetic_meta_data():\n\n combined_data = scrape_ew_and_errew.add_synthetic_meta_data(input_list = config_red[\"data_dirs\"][\"TEST_DIR_SRC\"] + config_red[\"file_names\"][\"TEST_LIST_SPEC_PHASE\"],\n read_in_filename = config_red[\"data_dirs\"][\"TEST_DIR_EW_PRODS\"]+config_red[\"file_names\"][\"TEST_RESTACKED_EW_DATA_W_NET_BALMER_ERRORS\"],\n write_out_filename = config_red[\"data_dirs\"][\"TEST_DIR_EW_PRODS\"]+config_red[\"file_names\"][\"TEST_RESTACKED_EW_DATA_W_METADATA_WRITEOUT\"])\n\n # columns from Robospect output and meta-data are all there\n assert \"wavel_stated_center\" in combined_data.columns\n assert \"feh\" in combined_data.columns\n assert \"teff\" in combined_data.columns\n # there are no nans in the table\n assert np.sum(combined_data.isnull().sum()) == 0\n" ]	[ [ "numpy.all", "matplotlib.use", "numpy.std" ] ]
CloudRenderVR/human-motion-prediction-pytorch-uncertainty	[ "cb96f3b2d8a2b54916b2f3f76c1c9b982af5b46b" ]	[ "src/translate.py" ]	[ "\n\"\"\"Simple code for training an RNN for motion prediction.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport math\nimport os\nimport random\nimport sys\nimport time\nimport h5py\n\nimport numpy as np\nfrom six.moves import xrange # pylint: disable=redefined-builtin\n\nimport data_utils\nimport seq2seq_model\nimport torch\nimport torch.optim as optim\nfrom torch.autograd import Variable\nimport argparse\n\n# Learning\nparser = argparse.ArgumentParser(description='Train RNN for human pose estimation')\nparser.add_argument('--learning_rate', dest='learning_rate',\n help='Learning rate',\n default=0.005, type=float)\nparser.add_argument('--learning_rate_decay_factor', dest='learning_rate_decay_factor',\n help='Learning rate is multiplied by this much. 1 means no decay.',\n default=0.95, type=float)\nparser.add_argument('--learning_rate_step', dest='learning_rate_step',\n help='Every this many steps, do decay.',\n default=10000, type=int)\nparser.add_argument('--batch_size', dest='batch_size',\n help='Batch size to use during training.',\n default=16, type=int)\nparser.add_argument('--max_gradient_norm', dest='max_gradient_norm',\n help='Clip gradients to this norm.',\n default=5, type=float)\nparser.add_argument('--iterations', dest='iterations',\n help='Iterations to train for.',\n default=1e5, type=int)\nparser.add_argument('--test_every', dest='test_every',\n help='',\n default=1000, type=int)\n# Architecture\nparser.add_argument('--architecture', dest='architecture',\n help='Seq2seq architecture to use: [basic, tied].',\n default='tied', type=str)\nparser.add_argument('--loss_to_use', dest='loss_to_use',\n help='The type of loss to use, supervised or sampling_based',\n default='sampling_based', type=str)\nparser.add_argument('--residual_velocities', dest='residual_velocities',\n help='Add a residual connection that effectively models velocities',action='store_true',\n default=False)\nparser.add_argument('--size', dest='size',\n help='Size of each model layer.',\n default=1024, type=int)\nparser.add_argument('--num_layers', dest='num_layers',\n help='Number of layers in the model.',\n default=1, type=int)\nparser.add_argument('--seq_length_in', dest='seq_length_in',\n help='Number of frames to feed into the encoder. 25 fp',\n default=50, type=int)\nparser.add_argument('--seq_length_out', dest='seq_length_out',\n help='Number of frames that the decoder has to predict. 25fps',\n default=10, type=int)\nparser.add_argument('--omit_one_hot', dest='omit_one_hot',\n help='', action='store_true',\n default=False)\nparser.add_argument('--taylor', dest='finite_taylor_extrapolate',\n help='Whether to augment the network with a taylor series extrapolation from a finite difference scheme of the previous frames', action='store_true',\n default=False)\n# Directories\nparser.add_argument('--data_dir', dest='data_dir',\n help='Data directory',\n default=os.path.normpath(\"./data/h3.6m/dataset\"), type=str)\nparser.add_argument('--train_dir', dest='train_dir',\n help='Training directory',\n default=os.path.normpath(\"./experiments/\"), type=str)\nparser.add_argument('--action', dest='action',\n help='The action to train on. all means all the actions, all_periodic means walking, eating and smoking',\n default='all', type=str)\nparser.add_argument('--use_cpu', dest='use_cpu',\n help='', action='store_true',\n default=False)\nparser.add_argument('--load', dest='load',\n help='Try to load a previous checkpoint.',\n default=0, type=int)\nparser.add_argument('--sample', dest='sample',\n help='Set to True for sampling.', action='store_true',\n default=False)\nparser.add_argument('--distribution_output_direct', dest='distribution_output_direct',\n default=False)\n\nargs = parser.parse_args()\n\ntrain_dir = os.path.normpath(os.path.join( args.train_dir, args.action,\n 'out_{0}'.format(args.seq_length_out),\n 'iterations_{0}'.format(args.iterations),\n args.architecture,\n args.loss_to_use,\n 'omit_one_hot' if args.omit_one_hot else 'one_hot',\n 'depth_{0}'.format(args.num_layers),\n 'size_{0}'.format(args.size),\n 'lr_{0}'.format(args.learning_rate),\n 'residual_vel' if args.residual_velocities else 'not_residual_vel'))\n\nprint(train_dir)\nos.makedirs(train_dir, exist_ok=True)\n\ndef create_model(actions, sampling=False):\n \"\"\"Create translation model and initialize or load parameters in session.\"\"\"\n model = seq2seq_model.Seq2SeqModel(\n args.architecture,\n args.seq_length_in if not sampling else 50,\n args.seq_length_out if not sampling else 100,\n args.size, # hidden layer size\n args.num_layers,\n args.max_gradient_norm,\n args.batch_size,\n args.learning_rate,\n args.learning_rate_decay_factor,\n args.loss_to_use if not sampling else \"sampling_based\",\n len( actions ),\n not args.omit_one_hot,\n args.residual_velocities,\n args.finite_taylor_extrapolate,\n output_as_normal_distribution = args.distribution_output_direct,\n dtype=torch.float32)\n\n if args.load <= 0:\n return model\n\n print(\"Loading model\")\n model = torch.load(train_dir + '/model_' + str(args.load))\n if sampling:\n model.source_seq_len = 50\n model.target_seq_len = 100\n return model\n\ndef clean_batch(batch):\n encoder_inputs, decoder_inputs, decoder_outputs = batch\n encoder_inputs = torch.from_numpy(encoder_inputs).float()\n decoder_inputs = torch.from_numpy(decoder_inputs).float()\n decoder_outputs = torch.from_numpy(decoder_outputs).float()\n if not args.use_cpu:\n encoder_inputs = encoder_inputs.cuda()\n decoder_inputs = decoder_inputs.cuda()\n decoder_outputs = decoder_outputs.cuda()\n encoder_inputs = Variable(encoder_inputs)\n decoder_inputs = Variable(decoder_inputs)\n decoder_outputs = Variable(decoder_outputs)\n return (encoder_inputs, decoder_inputs, decoder_outputs)\n\n\nimport flags\ndef get_loss(output, truth):\n if flags.translate_loss_func == \"mse\":\n return ( (output-truth)*2 ).mean()\n if flags.translate_loss_func == \"me\":\n return ( np.abs(output-truth) ).mean()\n if flags.translate_loss_func == \"mle\":\n assert(output.shape[-1] == truth.shape[-1] 2)\n means = output[..., :int(truth.shape[-1])]\n sigmas = output[..., int(truth.shape[-1]):]\n #print(\"################################\")\n neg_log_likelihood = torch.sum(torch.log(torch.pow(sigmas, 2))) / 2.0\n\n p1 = (means - truth)\n p2 = p1 / sigmas\n p3 = torch.pow(p2, 2)\n #print(\"Sigma likelihood cont:\", neg_log_likelihood)\n neg_log_likelihood += torch.numel(means) / 2.0 * np.log(2.03.1415926)\n neg_log_likelihood += torch.sum(p3) / 2.0\n #print(\"Max Means:\", torch.max(means))\n #print(\"Min Sigmas:\", torch.min(sigmas))\n #print(\"p1 max:\", torch.max(torch.abs(p1)))\n #print(\"p1 avg:\", torch.mean(torch.abs(p1)))\n #print(\"p2 max:\", torch.max(torch.abs(p2)))\n #print(\"p3 max:\", torch.max(p3))\n #print(\"p3 min:\", torch.min(p3))\n #print(\"p3 avg:\", torch.mean(p3))\n #print(\"likelihood:\", neg_log_likelihood)\n return neg_log_likelihood\n\ndef train():\n \"\"\"Train a seq2seq model on human motion\"\"\"\n\n actions = define_actions( args.action )\n\n number_of_actions = len( actions )\n\n #these will all be expangles\n train_set, test_set, data_mean, data_std, dim_to_ignore, dim_to_use = read_all_data(\n actions, args.seq_length_in, args.seq_length_out, args.data_dir, not args.omit_one_hot )\n\n # Limit TF to take a fraction of the GPU memory\n\n if True:\n model = create_model(actions, args.sample)\n if not args.use_cpu:\n model = model.cuda()\n\n # === Read and denormalize the gt with srnn's seeds, as we'll need them\n # many times for evaluation in Euler Angles ===\n srnn_gts_euler = get_srnn_gts( actions, model, test_set, data_mean,\n data_std, dim_to_ignore, not args.omit_one_hot )\n\n #=== This is the training loop ===\n step_time, loss, val_loss = 0.0, 0.0, 0.0\n current_step = 0 if args.load <= 0 else args.load + 1\n previous_losses = []\n\n step_time, loss = 0, 0\n optimiser = optim.SGD(model.parameters(), lr=args.learning_rate)\n #optimiser = optim.Adam(model.parameters(), lr=learning_rate, betas = (0.9, 0.999))\n\n for _ in range( args.iterations ):\n optimiser.zero_grad()\n model.train()\n\n start_time = time.time()\n\n # Actual training\n\n # === Training step ===\n encoder_inputs, decoder_inputs, decoder_outputs = clean_batch(model.get_batch( train_set, not args.omit_one_hot ))\n preds = model(encoder_inputs, decoder_inputs)\n step_loss = get_loss(preds, decoder_outputs)\n \n # Actual backpropagation\n step_loss.backward()\n optimiser.step()\n\n step_loss = step_loss.cpu().data.numpy()\n # TODO:\n preds = preds[..., :54]\n #if current_step % 100 == 0:\n # print(\"step {0:04d}; step_loss: {1:.4f}\".format(current_step, step_loss ))\n\n step_time += (time.time() - start_time) / args.test_every\n loss += step_loss / args.test_every\n current_step += 1\n # === step decay ===\n if current_step % args.learning_rate_step == 0:\n args.learning_rate = args.learning_rateargs.learning_rate_decay_factor\n optimiser = optim.Adam(model.parameters(), lr=args.learning_rate, betas = (0.9, 0.999))\n print(\"Decay learning rate. New value at \" + str(args.learning_rate))\n\n #cuda.empty_cache()\n\n # Once in a while, we save checkpoint, print statistics, and run evals.\n if current_step % args.test_every == 0:\n model.eval()\n\n # === Validation with randomly chosen seeds ===\n encoder_inputs, decoder_inputs, decoder_outputs = clean_batch(model.get_batch( test_set, not args.omit_one_hot ))\n \n preds = model(encoder_inputs, decoder_inputs)\n mse_loss = torch.mean( (preds[..., :54] - decoder_outputs)*2)\n step_loss = get_loss(preds, decoder_outputs)\n val_loss = step_loss # Loss book-keeping\n # TODO:\n preds = preds[..., :54]\n print()\n print(\"{0: <16} \|\".format(\"milliseconds\"), end=\"\")\n for ms in [80, 160, 320, 400, 560, 1000]:\n print(\" {0:5d} \|\".format(ms), end=\"\")\n print()\n\n # === Validation with srnn's seeds ===\n for action in actions:\n\n # Evaluate the model on the test batches\n #### Evaluate model on action\n encoder_inputs, decoder_inputs, decoder_outputs = clean_batch(model.get_batch(test_set, action))\n \n srnn_poses = model(encoder_inputs, decoder_inputs)\n\n\n srnn_loss = get_loss(srnn_poses, decoder_outputs)\n #TODO:\n srnn_poses = srnn_poses[...,:54]\n \n srnn_poses = srnn_poses.cpu().data.numpy()\n srnn_poses = srnn_poses.transpose([1,0,2])\n\n srnn_loss = srnn_loss.cpu().data.numpy()\n # Denormalize the output\n srnn_pred_expmap = data_utils.revert_output_format( srnn_poses,\n data_mean, data_std, dim_to_ignore, actions, not args.omit_one_hot )\n\n # Save the errors here\n mean_errors = np.zeros( (len(srnn_pred_expmap), srnn_pred_expmap[0].shape[0]) )\n\n # Training is done in exponential map, but the error is reported in\n # Euler angles, as in previous work.\n # See https://github.com/asheshjain399/RNNexp/issues/6#issuecomment-247769197\n N_SEQUENCE_TEST = 8\n for i in np.arange(N_SEQUENCE_TEST):\n eulerchannels_pred = srnn_pred_expmap[i]\n\n # Convert from exponential map to Euler angles\n for j in np.arange( eulerchannels_pred.shape[0] ):\n for k in np.arange(3,97,3):\n eulerchannels_pred[j,k:k+3] = data_utils.rotmat2euler(\n data_utils.expmap2rotmat( eulerchannels_pred[j,k:k+3] ))\n\n # The global translation (first 3 entries) and global rotation\n # (next 3 entries) are also not considered in the error, so the_key\n # are set to zero.\n # See https://github.com/asheshjain399/RNNexp/issues/6#issuecomment-249404882\n gt_i=np.copy(srnn_gts_euler[action][i])\n gt_i[:,0:6] = 0\n\n # Now compute the l2 error. The following is numpy port of the error\n # function provided by Ashesh Jain (in matlab), available at\n # https://github.com/asheshjain399/RNNexp/blob/srnn/structural_rnn/CRFProblems/H3.6m/dataParser/Utils/motionGenerationError.m#L40-L54\n idx_to_use = np.where( np.std( gt_i, 0 ) > 1e-4 )[0]\n \n euc_error = np.power( gt_i[:,idx_to_use] - eulerchannels_pred[:,idx_to_use], 2)\n euc_error = np.sum(euc_error, 1)\n euc_error = np.sqrt( euc_error )\n mean_errors[i,:] = euc_error\n\n # This is simply the mean error over the N_SEQUENCE_TEST examples\n mean_mean_errors = np.mean( mean_errors, 0 )\n\n # Pretty print of the results for 80, 160, 320, 400, 560 and 1000 ms\n print(\"{0: <16} \|\".format(action), end=\"\")\n for ms in [1,3,7,9,13,24]:\n if args.seq_length_out >= ms+1:\n print(\" {0:.3f} \|\".format( mean_mean_errors[ms] ), end=\"\")\n else:\n print(\" n/a \|\", end=\"\")\n print()\n\n print()\n print(\"============================\\n\"\n \"Global step: %d\\n\"\n \"Learning rate: %.4f\\n\"\n \"Step-time (ms): %.4f\\n\"\n \"Train loss avg: %.4f\\n\"\n \"--------------------------\\n\"\n \"Val loss: %.4f\\n\"\n \"srnn loss: %.4f\\n\"\n \"MSE loss: %.4f\\n\"\n \"============================\" % (current_step,\n args.learning_rate, step_time1000, loss,\n val_loss, srnn_loss, mse_loss))\n with open(\"training_out.txt\", 'a+') as f:\n f.write(action + \" \" + str(current_step)+\": \"+str(val_loss)+\"\\n\")\n torch.save(model, train_dir + '/model_' + str(current_step))\n\n print()\n previous_losses.append(loss)\n\n # Reset global time and loss\n step_time, loss = 0, 0\n\n sys.stdout.flush()\n\n\ndef get_srnn_gts( actions, model, test_set, data_mean, data_std, dim_to_ignore, one_hot, to_euler=True ):\n \"\"\"\n Get the ground truths for srnn's sequences, and convert to Euler angles (by default).\n (the error is always computed in Euler angles).\n\n Args\n actions: a list of actions to get ground truths for.\n model: training model we are using (we only use the \"get_batch\" method).\n test_set: dictionary with normalized training data.\n data_mean: d-long vector with the mean of the training data.\n data_std: d-long vector with the standard deviation of the training data.\n dim_to_ignore: dimensions that we are not using to train/predict.\n one_hot: whether the data comes with one-hot encoding indicating action.\n to_euler: whether to convert the angles to Euler format or keep thm in exponential map\n\n Returns\n srnn_gts_euler: a dictionary where the keys are actions, and the values\n are the ground_truth, denormalized expected outputs of srnns's seeds.\n \"\"\"\n srnn_gts_euler = {}\n\n for action in actions:\n\n srnn_gt_euler = []\n _, _, srnn_expmap = model.get_batch_srnn( test_set, action )\n\n # expmap -> rotmat -> euler\n for i in np.arange( srnn_expmap.shape[0] ):\n denormed = data_utils.unNormalizeData(srnn_expmap[i,:,:], data_mean, data_std, dim_to_ignore, actions, one_hot )\n\n if to_euler:\n for j in np.arange( denormed.shape[0] ):\n for k in np.arange(3,97,3):\n denormed[j,k:k+3] = data_utils.rotmat2euler( data_utils.expmap2rotmat( denormed[j,k:k+3] ))\n\n srnn_gt_euler.append( denormed );\n\n # Put back in the dictionary\n srnn_gts_euler[action] = srnn_gt_euler\n\n return srnn_gts_euler\n\n\ndef sample():\n \"\"\"Sample predictions for srnn's seeds\"\"\"\n actions = define_actions( args.action )\n\n if True:\n # === Create the model ===\n print(\"Creating %d layers of %d units.\" % (args.num_layers, args.size))\n sampling = True\n model = create_model(actions, sampling)\n if not args.use_cpu:\n model = model.cuda()\n print(\"Model created\")\n\n # Load all the data\n train_set, test_set, data_mean, data_std, dim_to_ignore, dim_to_use = read_all_data(\n actions, args.seq_length_in, args.seq_length_out, args.data_dir, not args.omit_one_hot )\n\n # === Read and denormalize the gt with srnn's seeds, as we'll need them\n # many times for evaluation in Euler Angles ===\n srnn_gts_expmap = get_srnn_gts( actions, model, test_set, data_mean,\n data_std, dim_to_ignore, not args.omit_one_hot, to_euler=False )\n srnn_gts_euler = get_srnn_gts( actions, model, test_set, data_mean,\n data_std, dim_to_ignore, not args.omit_one_hot )\n # Clean and create a new h5 file of samples\n SAMPLES_FNAME = 'samples.h5'\n try:\n os.remove( SAMPLES_FNAME )\n except OSError:\n pass\n\n # Predict and save for each action\n for action in actions:\n\n # Make prediction with srnn' seeds. These will just be in expangles.\n encoder_inputs, decoder_inputs, decoder_outputs = model.get_batch_srnn( test_set, action )\n\n encoder_inputs = torch.from_numpy(encoder_inputs).float()\n decoder_inputs = torch.from_numpy(decoder_inputs).float()\n decoder_outputs = torch.from_numpy(decoder_outputs).float()\n if not args.use_cpu:\n encoder_inputs = encoder_inputs.cuda()\n decoder_inputs = decoder_inputs.cuda()\n decoder_outputs = decoder_outputs.cuda()\n encoder_inputs = Variable(encoder_inputs)\n decoder_inputs = Variable(decoder_inputs)\n decoder_outputs = Variable(decoder_outputs)\n\n srnn_poses = model(encoder_inputs, decoder_inputs)\n\n srnn_loss = (srnn_poses[..., :54] - decoder_outputs)**2\n srnn_loss.cpu().data.numpy()\n srnn_loss = srnn_loss.mean()\n\n srnn_poses = srnn_poses.cpu().data.numpy()\n srnn_poses = srnn_poses.transpose([1,0,2])\n\n srnn_loss = srnn_loss.cpu().data.numpy()\n # denormalizes too\n srnn_pred_expmap = data_utils.revert_output_format(srnn_poses[..., :54], data_mean, data_std, dim_to_ignore, actions, not args.omit_one_hot )\n\n # Save the samples\n with h5py.File( SAMPLES_FNAME, 'a' ) as hf:\n for i in np.arange(8):\n # Save conditioning ground truth\n node_name = 'expmap/gt/{1}_{0}'.format(i, action)\n hf.create_dataset( node_name, data=srnn_gts_expmap[action][i] )\n # Save prediction\n node_name = 'expmap/preds/{1}_{0}'.format(i, action)\n hf.create_dataset( node_name, data=srnn_pred_expmap[i] )\n\n # Compute and save the errors here\n mean_errors = np.zeros( (len(srnn_pred_expmap), srnn_pred_expmap[0].shape[0]) )\n\n for i in np.arange(8):\n\n eulerchannels_pred = srnn_pred_expmap[i]\n\n for j in np.arange( eulerchannels_pred.shape[0] ):\n for k in np.arange(3,97,3):\n eulerchannels_pred[j,k:k+3] = data_utils.rotmat2euler(\n data_utils.expmap2rotmat( eulerchannels_pred[j,k:k+3] ))\n\n eulerchannels_pred[:,0:6] = 0\n\n # Pick only the dimensions with sufficient standard deviation. Others are ignored.\n idx_to_use = np.where( np.std( eulerchannels_pred, 0 ) > 1e-4 )[0]\n\n euc_error = np.power( srnn_gts_euler[action][i][:,idx_to_use] - eulerchannels_pred[:,idx_to_use], 2)\n euc_error = np.sum(euc_error, 1)\n euc_error = np.sqrt( euc_error )\n mean_errors[i,:] = euc_error\n\n mean_mean_errors = np.mean( mean_errors, 0 )\n print( action )\n print( ','.join(map(str, mean_mean_errors.tolist() )) )\n\n with h5py.File( SAMPLES_FNAME, 'a' ) as hf:\n node_name = 'mean_{0}_error'.format( action )\n hf.create_dataset( node_name, data=mean_mean_errors )\n\n return\n\n\ndef define_actions( action ):\n \"\"\"\n Define the list of actions we are using.\n\n Args\n action: String with the passed action. Could be \"all\"\n Returns\n actions: List of strings of actions\n Raises\n ValueError if the action is not included in H3.6M\n \"\"\"\n\n actions = [\"walking\", \"eating\", \"smoking\", \"discussion\", \"directions\",\n \"greeting\", \"phoning\", \"posing\", \"purchases\", \"sitting\",\n \"sittingdown\", \"takingphoto\", \"waiting\", \"walkingdog\",\n \"walkingtogether\"]\n\n if action in actions:\n return [action]\n\n if action == \"all\":\n return actions\n\n if action == \"all_srnn\":\n return [\"walking\", \"eating\", \"smoking\", \"discussion\"]\n\n raise( ValueError, \"Unrecognized action: %d\" % action )\n\n\ndef read_all_data( actions, seq_length_in, seq_length_out, data_dir, one_hot ):\n \"\"\"\n Loads data for training/testing and normalizes it ALSO REMOVING UNUSED DIMENSIONS AS DEFINED IN\n normalization_stats()!\n Does nothing to rotation format.\n\n Args\n actions: list of strings (actions) to load\n seq_length_in: number of frames to use in the burn-in sequence\n seq_length_out: number of frames to use in the output sequence\n data_dir: directory to load the data from\n one_hot: whether to use one-hot encoding per action\n Returns\n train_set: dictionary with normalized training data\n test_set: dictionary with test data\n data_mean: d-long vector with the mean of the training data\n data_std: d-long vector with the standard dev of the training data\n dim_to_ignore: dimensions that are not used becaused stdev is too small\n dim_to_use: dimensions that we are actually using in the model\n \"\"\"\n\n # === Read training data ===\n print (\"Reading training data (seq_len_in: {0}, seq_len_out {1}).\".format(\n seq_length_in, seq_length_out))\n\n train_subject_ids = [1,6,7,8,9,11]\n test_subject_ids = [5]\n\n train_set, complete_train = data_utils.load_data( data_dir, train_subject_ids, actions, one_hot )\n test_set, complete_test = data_utils.load_data( data_dir, test_subject_ids, actions, one_hot )\n\n #Convert to euler angles here I guess?\n\n\n # Compute normalization stats\n data_mean, data_std, dim_to_ignore, dim_to_use = data_utils.normalization_stats(complete_train)\n\n # Normalize -- subtract mean, divide by stdev\n train_set = data_utils.normalize_data( train_set, data_mean, data_std, dim_to_use, actions, one_hot )\n test_set = data_utils.normalize_data( test_set, data_mean, data_std, dim_to_use, actions, one_hot )\n print(\"done reading data.\")\n\n return train_set, test_set, data_mean, data_std, dim_to_ignore, dim_to_use\n\n\ndef main():\n if args.sample:\n sample()\n else:\n import sys\n with open(\"training_out.txt\", 'a+') as f:\n f.write(\"============================================================\\n\"+str(sys.argv)+\"\\n\")\n\n train()\n\nif __name__ == \"__main__\":\n main()\n" ]	[ [ "torch.mean", "numpy.log", "numpy.sum", "numpy.abs", "numpy.sqrt", "numpy.power", "numpy.arange", "torch.sum", "torch.from_numpy", "torch.numel", "numpy.copy", "numpy.std", "numpy.mean", "torch.pow", "torch.autograd.Variable" ] ]
gjdv/autoimpute	[ "d22cd86db6facd4a68746c8c0fcb3fae70071dac" ]	[ "autoimpute/analysis/metrics.py" ]	[ "\"\"\"This module devises metrics to compare estimates from analysis models.\"\"\"\n\nimport numpy as np\nimport pandas as pd\n\ndef raw_bias(Q_bar, Q):\n \"\"\"Calculate raw bias between coefficients Q and actual Q.\n\n Q_bar can be one estimate (scalar) or a vector of estimates. This equation\n subtracts the expected Q_bar from Q, element-wise. The result is the bias\n of each coefficient from its true value.\n\n Args:\n Q_bar (number, array): single estimate or array of estimates.\n Q (number, array): single truth or array of truths.\n\n Returns:\n scalar, array: element-wise difference between estimates and truths.\n\n Raises:\n ValueError: Shape mismatch\n ValueError: Q_bar and Q not the same length\n \"\"\"\n\n # handle errors first\n shape_err = \"Q_bar & Q must be scalars or vectors of same length.\"\n if isinstance(Q_bar, pd.DataFrame):\n s = len(Q_bar.shape)\n if s != 1:\n raise ValueError(shape_err)\n\n if isinstance(Q, pd.DataFrame):\n s = len(Q.shape)\n if s != 1:\n raise ValueError(shape_err)\n\n if len(Q_bar) != len(Q):\n raise ValueError(shape_err)\n\n # convert any lists to ensure element-wise performed\n if isinstance(Q_bar, (tuple, list)):\n Q_bar = np.array(Q_bar)\n\n if isinstance(Q, (tuple, list)):\n Q = np.array(Q)\n\n # perform element-wise subtraction\n rb = Q_bar - Q\n return rb\n\ndef percent_bias(Q_bar, Q):\n \"\"\"Calculate precent bias between coefficients Q and actual Q.\n\n Q_bar can be one estimate (scalar) or a vector of estimates. This equation\n subtracts the expected Q_bar from Q, element-wise. The result is the bias\n of each coefficient from its true value. We then divide this number by\n Q itself, again in element-wise fashion, to produce % bias.\n\n Args:\n Q_bar (number, array): single estimate or array of estimates.\n Q (number, array): single truth or array of truths.\n\n Returns:\n scalar, array: element-wise difference between estimates and truths.\n\n Raises:\n ValueError: Shape mismatch\n ValueError: Q_bar and Q not the same length\n \"\"\"\n # calling this method will validate Q_bar and Q\n rb = raw_bias(Q_bar, Q)\n\n # convert Q if necessary. must re-perform operation\n if isinstance(Q, (tuple, list)):\n Q = np.array(Q)\n\n pct_bias = 100 * (abs(rb)/Q)\n return pct_bias\n" ]	[ [ "numpy.array" ] ]
hadleyhzy34/GANs-practice	[ "37d1dcf4e4b492e6d070b0ba72f320913af9b17a" ]	[ "gan/PyTorch-GAN-Mnist/test.py" ]	[ "import torch\nfrom torchvision import transforms\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport matplotlib.gridspec as gridspec\n\n\n\nplt.rcParams['figure.figsize'] = (10.0, 8.0)\nplt.rcParams['image.interpolation'] = 'nearest'\nplt.rcParams['image.cmap'] = 'gray'\n\n\ndef show_images(images):\n sqrtn = int(np.ceil(np.sqrt(images.shape[0])))\n\n for index, image in enumerate(images):\n plt.subplot(sqrtn, sqrtn, index+1)\n plt.imshow(image.reshape(28, 28))\n\n\ndevice = 'cuda:0' if torch.cuda.is_available() else 'cpu'\nprint('GPU State:', device)\n\n# Model\nG = torch.load('Generator_epoch_200.pth')\nG.eval()\n\n# Generator\nnoise = (torch.rand(16, 128)-0.5) / 0.5\nnoise = noise.to(device)\n\nfake_image = G(noise)\nimgs_numpy = (fake_image.data.cpu().numpy()+1.0)/2.0\nshow_images(imgs_numpy)\nplt.show()\n\n" ]	[ [ "numpy.sqrt", "torch.load", "matplotlib.pyplot.subplot", "torch.rand", "torch.cuda.is_available", "matplotlib.pyplot.show" ] ]
Diimu/circuitsimulator	[ "3a4aeaaa89b5e9bba1598736140e32b3ca1e0da4" ]	[ "circuit.py" ]	[ "# -- coding: utf-8 --\n\"\"\"\nClass \"Circuit\" defines simple one port object/circuit having\nfrequency (single point or array), impedance, and possibly a list\nof components that constitute the circuit.\n\"\"\"\n\n\nimport numpy as np\nimport scipy\nimport matplotlib.pyplot as plt\nimport skrf\n\nclass Circuit:\n \n def __init__(self, f, Z, Z0=50, draw_smith=True):\n self.Z = Z\n self.f = f\n self.Z0 = Z0\n self.draw_smith=draw_smith\n self.components = [('start', Z)]\n \n\n if np.size(self.f)==1 and self.draw_smith: #single frequency -> plot transition on smith chart\n skrf.plotting.plot_smith(self.refl(self.Z), marker='o', color='k', linestyle=None, x_label='',y_label='', title='Smith chart, matching network', label='start')\n #self.components is an array of tuples containing the history of the circuit,\n #i.e., all components attached to the circuit\n\n def __str__(self):\n if not isinstance(self.f, np.ndarray):\n freq, multi = find_si_prefix(self.f)\n ret = \"{:.2f}+j{:2f} ohm at {:.2f} {:s}Hz:\\n\".format(self.Z.real, self.Z.imag, freq, multi)\n else:\n return \"not implemented for freq range\"\n \n for component in self.components:\n prefix = find_si_prefix(component[1], False)\n ct = '' #component type\n cc = '' #component connection\n unit = ''\n n = component[0]\n if n.find('cap') >= 0:\n ct = 'capacitor'\n unit = 'F'\n elif n.find('ind') >= 0:\n ct = 'inductor'\n unit = 'H'\n elif n.find('line') >= 0:\n ct = 'line'\n unit = '\\pi'\n \n if n.find('ser') >= 0:\n cc = 'Series'\n elif n.find('par') >= 0:\n cc = 'Parallel' \n elif n.find('start') >= 0:\n cc = 'Start' \n \n ret += '{:s} {:s}: {:.2f} {:s}{:s}\\n'.format(cc, ct, prefix[0], prefix[1], unit)\n \n \n \n return ret\n \n def cap(self, C):\n '''\n impedance of a capacitor at frequency of this circuit\n '''\n return cap(self.f, C)\n \n def ind(self, L):\n return ind(self.f, L)\n \n \n def refl(self, Z=None):\n '''\n returns the reflection coefficient of the present circuit\n '''\n if Z is None:\n return refl(self.Z,self.Z0)\n else:\n return refl(Z, self.Z0)\n \n def ser(self, Z):\n self.components.append(('ser',Z))\n if np.size(self.f)==1 and self.draw_smith: #single frequency -> plot transition on smith chart\n tmp = np.logspace(np.log10(Z/1000), np.log10(Z), 100)\n #impedance of a capacitance array, starting from very large cap\n #(large series capacitance == small change in impedance)\n tmp = ser(self.Z, tmp)\n #the array transformed into impedance\n\n scaled_value = find_si_prefix(Z)\n label = 'ser {:2g} {:s}$\\Omega$'.format(scaled_value[0], scaled_value[1])\n skrf.plotting.plot_smith(self.refl(tmp), x_label='',y_label='', title='Smith chart, matching network', label=label)\n \n self.Z += Z #after plotting, add series capacitance to the current impedance\n\n def par(self, Z):\n self.components.append(('par',Z))\n if np.size(self.f)==1 and self.draw_smith: #single frequency -> plot transition on smith chart\n tmp = np.logspace(np.log10(Z1000), np.log10(Z), 100)\n #impedance of a capacitance array, starting from very large cap\n #(large series capacitance == small change in impedance)\n tmp = par(self.Z, tmp)\n #the array transformed into impedance\n\n scaled_value = find_si_prefix(Z)\n label = 'par {:2g} {:s}$\\Omega$'.format(scaled_value[0], scaled_value[1])\n skrf.plotting.plot_smith(self.refl(tmp), x_label='',y_label='', title='Smith chart, matching network', label=label)\n \n self.Z = par(Z, self.Z) #after plotting, add series capacitance to the current impedance \n \n \n def sercap(self, C):\n '''\n Set a capacitor in series with the present circuit\n '''\n self.components.append(('sercap',C))\n if np.size(self.f)==1 and self.draw_smith: #single frequency -> plot transition on smith chart\n tmp = self.cap(np.logspace(np.log10(C1000), np.log10(C), 100)) \n #impedance of a capacitance array, starting from very large cap\n #(large series capacitance == small change in impedance)\n tmp = ser(self.Z, tmp)\n #the array transformed into impedance\n scaled_value = find_si_prefix(C)\n label = 'ser {:2g} {:s}F'.format(scaled_value[0], scaled_value[1])\n skrf.plotting.plot_smith(self.refl(tmp), x_label='',y_label='', title='Smith chart, matching network', label=label)\n \n self.Z = ser(self.Z, self.cap(C)) #after plotting, add series capacitance to the current impedance\n \n def serind(self, L):\n '''\n Set an inductor in series with the present circuit\n '''\n self.components.append(('serind',L))\n if np.size(self.f)==1 and self.draw_smith: #single frequency -> plot transition on smith chart\n tmp = self.ind(np.logspace(np.log10(L/1000), np.log10(L), 100)) \n #impedance of a capacitance array, starting from very small inductance\n tmp = ser(self.Z, tmp)\n #the array transformed into impedance\n scaled_value = find_si_prefix(L)\n label = 'ser {:2g} {:s}H'.format(scaled_value[0], scaled_value[1])\n skrf.plotting.plot_smith(self.refl(tmp), x_label='',y_label='', title='Smith chart, matching network', label=label)\n \n self.Z = ser(self.Z, self.ind(L)) #after plotting, add series inductance to the current impedance\n \n def parcap(self, C):\n '''\n Set a capacitor parallel to the present circuit\n '''\n self.components.append(('parcap',C))\n if np.size(self.f)==1 and self.draw_smith: #single frequency -> plot transition on smith chart\n tmp = self.cap(np.logspace(np.log10(C/1000), np.log10(C), 100)) \n #impedance of a capacitance array, starting from very small cap\n tmp = par(self.Z, tmp)\n #the array transformed into impedance\n scaled_value = find_si_prefix(C)\n label = 'ser {:2g} {:s}F'.format(scaled_value[0], scaled_value[1])\n skrf.plotting.plot_smith(self.refl(tmp), x_label='',y_label='', title='Smith chart, matching network', label=label)\n \n self.Z = par(self.Z, self.cap(C)) #after plotting, add series capacitance to the current impedance\n \n def parind(self, L):\n '''\n Set an inductor parallel to the present circuit\n '''\n self.components.append(('parind',L))\n if np.size(self.f)==1 and self.draw_smith: #single frequency -> plot transition on smith chart\n tmp = self.ind(np.logspace(np.log10(L1000), np.log10(L), 100)) \n #impedance of a capacitance array, starting from very large inductance\n #(large series capacitance == small change in impedance)\n tmp = par(self.Z, tmp)\n #the array transformed into impedance\n scaled_value = find_si_prefix(L)\n label = 'par {:2g} {:s}H'.format(scaled_value[0], scaled_value[1])\n skrf.plotting.plot_smith(self.refl(tmp), x_label='',y_label='', title='Smith chart, matching network', label=label)\n \n self.Z = par(self.Z, self.ind(L)) #after plotting, add series inductance to the current impedance\n\n def serline(self, kl, Z0=None):\n '''\n perform impedance as seen through a transmission line\n '''\n if Z0==None:\n Z0=self.Z0\n\n self.components.append(('serline',kl, Z0))\n if np.size(self.f)==1 and self.draw_smith: #single frequency -> plot transition on smith chart\n tmp = line(self.Z, np.linspace(0, kl, 100), Z0) \n label = 'line {:2g}'.format(kl)\n skrf.plotting.plot_smith(self.refl(tmp), x_label='',y_label='', title='Smith chart, matching network', label=label)\n \n self.Z = line(self.Z, kl, Z0) \n\n def parline(self, kl, Zl=np.inf, Z0=None):\n '''\n add a transmission line parallel to the current impedance (defaults to open self.Z0 ohm line)\n '''\n if Z0==None:\n Z0=self.Z0\n\n self.components.append(('parline',kl, Zl, Z0))\n if np.size(self.f)==1 and self.draw_smith: #single frequency -> plot transition on smith chart\n tmp = par(self.Z, line(Zl, np.linspace(0, kl, 100), Z0))\n label = 'par line {:2g}'.format(kl)\n skrf.plotting.plot_smith(self.refl(tmp), x_label='',y_label='', title='Smith chart, matching network', label=label)\n\n self.Z = par(self.Z0, line(Zl, kl, Z0)) \n \n def db(self, noextrastuff=False):\n '''\n For a point frequency return reflection coefficient, for a frequency range\n plot the response curve. noextrastuff means the labels and grids\n '''\n if np.size(self.f)==1:\n return 20np.log10(abs(self.refl()))\n elif noextrastuff:\n plt.plot(self.f, 20np.log10(abs(self.refl())))\n else:\n plt.figure()\n plt.plot(self.f, 20np.log10(np.abs(self.refl())))\n plt.ylabel('Reflection coefficient, dB')\n plt.xlabel('Frequency, Hz')\n plt.grid()\n \n def smith(self, annotations=True,smith_r=1, chart_type='z', x_label='',\n y_label='', title='Smith chart, frequency', show_legend=True,\n axis='equal', ax=None, force_chart = False, args, kwargs):\n '''\n plots the current mathcing network on the smith chart as the function of frequency\n '''\n if np.size(self.f)>1:\n plt.figure()\n skrf.plotting.plot_smith(self.refl(), smith_r=smith_r, chart_type=chart_type, x_label=x_label,\n y_label=y_label, title=title, show_legend=show_legend,\n axis=axis, ax=ax, force_chart = force_chart, args, *kwargs)\n \n if annotations:\n xy=(np.real(self.refl()[0]),np.imag(self.refl()[0]))\n plt.annotate('{:.2e}'.format(self.f[0]) , xy=xy,xycoords='data', xytext=(xy[0]/ np.abs(xy[0]), xy[1]/ np.abs(xy[1])), textcoords='data', arrowprops=dict(arrowstyle=\"->\")).draggable()\n xy=(np.real(self.refl()[-1]),np.imag(self.refl()[-1]))\n plt.annotate('{:.2e}'.format(self.f[-1]) , xy=xy,xycoords='data', xytext=(xy[0]/ np.abs(xy[0]), xy[1]/ np.abs(xy[1])), textcoords='data', arrowprops=dict(arrowstyle=\"->\")).draggable()\n \n ind = np.argmin(np.abs(self.refl()))\n xy=(np.real(self.refl()[ind]),np.imag(self.refl()[ind]))\n plt.annotate('{:.2e}\\n{:.1f} dB'.format(self.f[ind], 20np.log10(np.abs(self.refl()[ind]))) , xy=xy,xycoords='data', xytext=(xy[0]/ np.abs(xy[0])+0.2, xy[1]/ np.abs(xy[1])-0.2), textcoords='data', arrowprops=dict(arrowstyle=\"->\")).draggable()\n\n'''\nAfter this point the file defines basic equations used in Circuit class\n'''\n\ndef cap(f, C):\n '''\n impedance of a capacitor\n '''\n if isinstance(C, np.ndarray) or isinstance(f, np.ndarray):\n return 1/(1j2np.pifC)\n elif np.iscomplex(C) or f<0 or C<0:\n raise ValueError #bullshit numbers given\n else:\n return 1/(1j2np.pifC)\n\n\ndef ind(f, L):\n '''\n impedance of a inductor\n '''\n \n #TODO: check that input is valid. \n return 1j2np.pifL\n\ndef ser(Z1, Z2, Z3=0, Z4=0, Z5=0, Z6=0, Z7=0, Z8=0, Z9=0, Z10=0):\n '''\n impedance of a series of compoents\n '''\n return Z1+Z2+Z3+Z4+Z5+Z6+Z7+Z8+Z9+Z10\n\ndef par(Z1, Z2, Z3=np.inf, Z4=np.inf, Z5=np.inf, Z6=np.inf, Z7=np.inf, Z8=np.inf, Z9=np.inf, Z10=np.inf):\n '''\n impedance of parallel compoents\n '''\n return 1/(1/Z1+1/Z2+1/Z3+1/Z4+1/Z5+1/Z6+1/Z7+1/Z8+1/Z9+1/Z10)\n\ndef refl(Z, Z0=50):\n if isinstance(Z, np.ndarray):\n return (Z-Z0)/(Z+Z0)\n elif Z==np.inf and Z0<np.inf:\n return 1\n else:\n return (Z-Z0)/(Z+Z0)\n \ndef find_si_prefix(x, use_latex = True):\n '''\n return (numeric value , si-prefix)\n \n >>> find_si_prefix(5000)\n (5.0, 'k')\n '''\n if use_latex:\n prefixes = ['f', 'p', 'n', '$\\mu$', 'm', '', 'k','M','G']\n else:\n prefixes = ['f', 'p', 'n', 'u', 'm', '', 'k','M','G']\n multipliers = np.asarray([1e-15,1e-12, 1e-9, 1e-6,1e-3,1,1e3,1e6,1e9])\n for n, k in enumerate(x/multipliers):\n if 0.1<k<=(100 + 1e-10):\n break #loop the list until we find a prefix that sets the k to be in nice range\n return (k, prefixes[n])\n \ndef line(Z, kl, Z0=50):\n #from scipy.special import cotdg\n if Z != np.inf:\n Z = Z0 * (Z+1jZ0np.tan(kl))/(Z0 + 1j* Znp.tan(kl))\n else:\n np.seterr(divide='ignore') #lazy solution to situation kl=0 == divide by error\n Z = -1jZ0np.true_divide(1,np.tan(kl))# if np.tan(kl)==0 else 1jnp.inf\n #Z = -1jZ0np.cos(kl)/np.sin(kl)\n np.seterr(divide='warn')\n return Z \n \n\ndef db(Z, Z0=50):\n if Z==Z0: #avoid log(0)\n return -np.inf\n else:\n return 20*np.log10(abs(refl(Z, Z0)))\n \n \nif __name__ == '__main__':\n plt.ion()\n c = Circuit(64e6, 30)\n c.sercap(30e-12)\n c.parind(100e-9)\n\n\n" ]	[ [ "numpy.abs", "numpy.linspace", "numpy.asarray", "numpy.tan", "numpy.seterr", "numpy.size", "numpy.log10", "matplotlib.pyplot.ylabel", "matplotlib.pyplot.grid", "numpy.iscomplex", "matplotlib.pyplot.xlabel", "matplotlib.pyplot.ion", "matplotlib.pyplot.figure" ] ]
deepmipt/kpi2017	[ "0f6b13c6ea76e544804ce66ba372c66d5ef9ee30" ]	[ "deeppavlov/tasks/insults/build.py" ]	[ "# Copyright 2017 Neural Networks and Deep Learning lab, MIPT\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\nimport parlai.core.build_data as build_data\nimport os\nimport re\nimport string\nimport numpy as np\nimport pandas as pd\nimport urllib\n\n\ndef data_preprocessing(f):\n \"\"\"Preprocess the data.\n\n Args:\n f: list of text samples\n\n Returns:\n preprocessed list of text samples\n \"\"\"\n f = [x.lower() for x in f]\n f = [re.sub(r'^\"\|\"$', '', x) for x in f]\n f = [x.replace(\"\\\\n\", \" \") for x in f]\n f = [x.replace(\"\\\\t\", \" \") for x in f]\n f = [x.replace(\"\\\\xa0\", \" \") for x in f]\n f = [x.replace(\"\\\\xc2\", \" \") for x in f]\n\n f = [re.sub('!!+', ' !! ', x) for x in f]\n f = [re.sub('!', ' ! ', x) for x in f]\n f = [re.sub('! !', '!!', x) for x in f]\n\n f = [re.sub('\\?\\?+', ' ?? ', x) for x in f]\n f = [re.sub('\\?', ' ? ', x) for x in f]\n f = [re.sub('\\? \\?', '??', x) for x in f]\n\n f = [re.sub('\\?!+', ' ?! ', x) for x in f]\n\n f = [re.sub('\\.\\.+', '..', x) for x in f]\n f = [re.sub('\\.', ' . ', x) for x in f]\n f = [re.sub('\\. \\.', '..', x) for x in f]\n\n f = [re.sub(',', ' , ', x) for x in f]\n f = [re.sub(':', ' : ', x) for x in f]\n f = [re.sub(';', ' ; ', x) for x in f]\n f = [re.sub('\\%', ' % ', x) for x in f]\n\n f = [x.replace(\"$\", \"s\") for x in f]\n f = [x.replace(\" u \", \" you \") for x in f]\n f = [x.replace(\" em \", \" them \") for x in f]\n f = [x.replace(\" da \", \" the \") for x in f]\n f = [x.replace(\" yo \", \" you \") for x in f]\n f = [x.replace(\" ur \", \" your \") for x in f]\n f = [x.replace(\"you\\'re\", \"you are\") for x in f]\n f = [x.replace(\" u r \", \" you are \") for x in f]\n f = [x.replace(\"yo\\'re\", \" you are \") for x in f]\n f = [x.replace(\"yu\\'re\", \" you are \") for x in f]\n f = [x.replace(\"u\\'re\", \" you are \") for x in f]\n f = [x.replace(\" urs \", \" yours \") for x in f]\n f = [x.replace(\"y'all\", \"you all\") for x in f]\n\n f = [x.replace(\" r u \", \" are you \") for x in f]\n f = [x.replace(\" r you\", \" are you\") for x in f]\n f = [x.replace(\" are u \", \" are you \") for x in f]\n\n f = [x.replace(\" mom \", \" mother \") for x in f]\n f = [x.replace(\" momm \", \" mother \") for x in f]\n f = [x.replace(\" mommy \", \" mother \") for x in f]\n f = [x.replace(\" momma \", \" mother \") for x in f]\n f = [x.replace(\" mama \", \" mother \") for x in f]\n f = [x.replace(\" mamma \", \" mother \") for x in f]\n f = [x.replace(\" mum \", \" mother \") for x in f]\n f = [x.replace(\" mummy \", \" mother \") for x in f]\n\n f = [x.replace(\"won't\", \"will not\") for x in f]\n f = [x.replace(\"can't\", \"cannot\") for x in f]\n f = [x.replace(\"i'm\", \"i am\") for x in f]\n f = [x.replace(\" im \", \" i am \") for x in f]\n f = [x.replace(\"ain't\", \"is not\") for x in f]\n f = [x.replace(\"'ll\", \" will\") for x in f]\n f = [x.replace(\"'t\", \" not\") for x in f]\n f = [x.replace(\"'ve\", \" have\") for x in f]\n f = [x.replace(\"'s\", \" is\") for x in f]\n f = [x.replace(\"'re\", \" are\") for x in f]\n f = [x.replace(\"'d\", \" would\") for x in f]\n\n # replace multiple letters (3 and more) by 2 letters\n for letter in string.ascii_lowercase:\n f = [re.sub(letter * 3 + '+', letter, x).strip() for x in f]\n\n bad_words_file = open(os.path.join(os.path.dirname(os.path.realpath(__file__)), \"badwords.txt\"), \"r\")\n bwMap = dict()\n for line in bad_words_file:\n sp = line.strip().lower().split(\",\")\n if len(sp) == 2:\n bwMap[sp[0].strip()] = sp[1].strip()\n\n for key, value in bwMap.items():\n kpad = \" \" + key + \" \"\n vpad = \" \" + value + \" \"\n f = [x.replace(kpad, vpad) for x in f]\n\n # stemming\n f = [re.sub(\"ies( \|$)\", \"y \", x) for x in f]\n f = [re.sub(\"s( \|$)\", \" \", x) for x in f]\n f = [re.sub(\"ing( \|$)\", \" \", x) for x in f]\n f = [x.replace(\"tard \", \" \") for x in f]\n\n f = [re.sub(\" [$%&#@][$%&#@]+\", \" xexp \", x) for x in f]\n f = [re.sub(\" [0-9]+ \", \" DD \", x) for x in f]\n f = [re.sub(\"<\\S>\", \"\", x) for x in f]\n f = [re.sub('\\s+', ' ', x) for x in f]\n return f\n\n\ndef write_input_fasttext_cls(data, path, data_name):\n \"\"\"Write down input files for fasttext classificator.\n\n Args:\n data: array of text samples\n path: path to folder to put the files\n data_name: mode of writing files \"train\" or \"test\"\n\n Returns:\n nothing\n \"\"\"\n f = open(path + '_fasttext_cls.txt', 'w')\n for i in range(data.shape[0]):\n if data_name == 'train':\n f.write('__label__' + str(data.iloc[i,0]) + ' ' + data.iloc[i,1] + '\\n')\n elif data_name == 'test':\n f.write(data.iloc[i,1] + '\\n')\n else:\n print('Incorrect data name')\n f.close()\n\n\ndef write_input_fasttext_emb(data, path, data_name):\n \"\"\"Write down input files for fasttext embedding.\n\n Args:\n data: array of text samples\n path: path to folder to put the files\n data_name: mode of writing files \"train\" or \"test\"\n\n Returns:\n nothing\n \"\"\"\n f = open(path + '_fasttext_emb.txt', 'w')\n for i in range(data.shape[0]):\n if data_name == 'train' or data_name == 'test':\n f.write(data.iloc[i,1] + '\\n')\n else:\n print('Incorrect data name')\n f.close()\n\n\ndef balance_dataset(dataset_0, labels_0, dataset_1, labels_1, ratio=1):\n \"\"\"Balance the dataset_0 with samples from dataset_1 up to given ratio.\n\n Args:\n dataset_0: array of text samples\n labels_0: array of labels for dataset_0\n dataset_1: array of text samples\n labels_1: array of labels for dataset_1\n ratio: ratio of samples of class 1 to samples of class 0 (default 1.0)\n\n Returns:\n balanced array of text samples, corresponding array of labels\n \"\"\"\n initial_train_size = dataset_0.shape[0]\n insult_inds = np.nonzero(labels_1)[0]\n num_insults_0 = len(np.nonzero(labels_0)[0])\n num_insults_1 = len(np.nonzero(labels_1)[0])\n insult_inds_to_add = insult_inds[np.random.randint(low=0, high=num_insults_1,\n size=(ratio (initial_train_size - num_insults_0) - num_insults_0))]\n result = dataset_0.append(dataset_1.iloc[insult_inds_to_add])\n result_labels = labels_0.append(labels_1.iloc[insult_inds_to_add])\n return result, result_labels\n\n\ndef build(opt):\n \"\"\"Read and preprocess data, save preprocessed data, balance data,\n create input files for fasttext classifier and embeddings.\n\n Args:\n opt: given parameters\n\n Returns:\n nothing\n \"\"\"\n # get path to data directory\n dpath = os.path.join(opt['datapath'], 'insults')\n # define version if any\n version = '1.0'\n\n # check if data had been previously built\n if not build_data.built(dpath, version_string=version):\n print('[building data: ' + dpath + ']')\n\n # make a clean directory if needed\n if build_data.built(dpath):\n # an older version exists, so remove these outdated files.\n build_data.remove_dir(dpath)\n build_data.make_dir(dpath)\n\n raw_path = os.path.abspath(opt['raw_dataset_path'] or \".\")\n train_file = os.path.join(raw_path, 'train.csv')\n valid_file = os.path.join(raw_path, 'test_with_solutions.csv')\n test_file = os.path.join(raw_path, 'impermium_verification_labels.csv')\n if not os.path.isfile(train_file) or not os.path.isfile(valid_file) or not os.path.isfile(test_file):\n ds_path = os.environ.get('DATASETS_URL')\n file_name = 'insults.tar.gz'\n if not ds_path:\n raise RuntimeError('Please download dataset files from'\n ' https://www.kaggle.com/c/detecting-insults-in-social-commentary/data'\n ' and set path to their directory in raw-dataset-path parameter')\n print('Trying to download a insults dataset from the repository')\n url = urllib.parse.urljoin(ds_path, file_name)\n print(repr(url))\n build_data.download(url, dpath, file_name)\n build_data.untar(dpath, file_name)\n opt['raw_dataset_path'] = dpath\n print('Downloaded a insults dataset')\n\n raw_path = os.path.abspath(opt['raw_dataset_path'])\n train_file = os.path.join(raw_path, 'train.csv')\n valid_file = os.path.join(raw_path, 'test_with_solutions.csv')\n test_file = os.path.join(raw_path, 'impermium_verification_labels.csv')\n\n train_data = pd.read_csv(train_file)\n train_data = train_data.drop('Date', axis=1)\n\n test_data = pd.read_csv(test_file)\n test_data = test_data.drop('id', axis=1)\n test_data = test_data.drop('Usage', axis=1)\n test_data = test_data.drop('Date', axis=1)\n\n valid_data = pd.read_csv(valid_file)\n valid_data = valid_data.drop('Date', axis=1)\n valid_data = valid_data.drop('Usage', axis=1)\n\n # merge train and valid due to use of cross validation\n train_data = train_data.append(valid_data)\n\n if opt.get('balance_train_dataset'):\n if opt['balance_train_dataset']:\n train_data['Comment'],train_data['Insult'] = balance_dataset(train_data['Comment'],\n train_data['Insult'],\n train_data['Comment'],\n train_data['Insult'], ratio=1)\n\n print('Preprocessing train')\n train_data['Comment'] = data_preprocessing(train_data['Comment'])\n print('Preprocessing test')\n test_data['Comment'] = data_preprocessing(test_data['Comment'])\n\n print('Writing input files for fasttext')\n write_input_fasttext_cls(train_data, os.path.join(dpath, 'train'), 'train')\n write_input_fasttext_cls(test_data, os.path.join(dpath, 'test'), 'test')\n\n write_input_fasttext_emb(train_data, os.path.join(dpath, 'train'), 'train')\n write_input_fasttext_emb(test_data, os.path.join(dpath, 'test'), 'test')\n\n print('Writing input normalized input files')\n train_data.to_csv(os.path.join(dpath, 'train.csv'), index=False)\n test_data.to_csv(os.path.join(dpath, 'test.csv'), index=False)\n\n # mark the data as built\n build_data.mark_done(dpath, version_string=version)\n" ]	[ [ "pandas.read_csv", "numpy.nonzero", "numpy.random.randint" ] ]
kuldeep24680/RESTAPI-for-analyzing-data-to-excel-uploaded-file-and-downloading-resultant-csv-files-on-flask	[ "5e3f35de2599f71078974c4e5a46bb94da426200" ]	[ "routes.py" ]	[ "from app import app\r\nfrom flask import render_template, request,send_file\r\nimport pandas as pd\r\nimport csv\r\nimport xlrd\r\n\r\n\r\n\r\n# to route the user the upload the .xlsx file\r\[email protected]('/')\r\ndef upload_file():\r\n return render_template('upload.html')\r\n\r\n# function that converts the .xlsx file into .csv file and saves it into input folder as test.csv which is used for further analytics \r\[email protected]('/Fileupload', methods = ['POST'])\r\ndef upload():\r\n if request.method == 'POST':\r\n f = request.files['file']\r\n f.save(\"input/sample.xlsx\")\r\n wb = xlrd.open_workbook('input/sample.xlsx')\r\n sh = wb.sheet_by_name('Raw Data')\r\n your_csv_file = open('input/test.csv', 'w')\r\n wr = csv.writer(your_csv_file, quoting=csv.QUOTE_ALL)\r\n\r\n for rownum in range(sh.nrows):\r\n wr.writerow(sh.row_values(rownum))\r\n\r\n your_csv_file.close()\r\n\r\n\r\n return 'file uploaded successfully'\r\n# function that reads the test.csv and creates dataframe from which a filtered dataframe is generated which contains all the metabolics with suffix as PC and later write it a file\r\[email protected]('/metabolic_suffix_PC')\r\ndef metabolic_suffix_PC():\r\n column_names = pd.read_csv('input/test.csv', engine='python')\r\n columns=list(column_names.columns.values)\r\n dict={}\r\n for i in range(len(columns)):\r\n dict[i]=columns[i]\r\n\r\n\r\n csv_df = pd.read_csv('input/test.csv', header=None, skiprows=1, engine='python')\r\n child_dataset1 = csv_df[csv_df[2].str.endswith('PC', na=False)]\r\n child_dataset1.rename(columns=dict,inplace=True)\r\n tfile = open('outputs/output_PC.csv', 'w')\r\n tfile.write(child_dataset1.to_string())\r\n tfile.close()\r\n return send_file('outputs/output_PC.csv',\r\n mimetype='text/csv',\r\n attachment_filename='output_PC.csv',\r\n as_attachment=True)\r\n\r\n# function that reads the test.csv and creates dataframe from which a filtered dataframe is generated which contains all the metabolics with suffix as LPC and later write it a file\r\[email protected]('/metabolic_suffix_LPC')\r\ndef metabolic_suffix_LPC():\r\n column_names = pd.read_csv('input/test.csv', engine='python')\r\n columns=list(column_names.columns.values)\r\n dict={}\r\n for i in range(len(columns)):\r\n dict[i]=columns[i]\r\n\r\n\r\n csv_df = pd.read_csv('input/test.csv', header=None, skiprows=1, engine='python')\r\n child_dataset2 = csv_df[csv_df[2].str.endswith('LPC', na=False)]\r\n child_dataset2.rename(columns=dict,inplace=True)\r\n tfile = open('outputs/output_LPC.csv', 'w')\r\n tfile.write(child_dataset2.to_string())\r\n tfile.close()\r\n return send_file('outputs/output_LPC.csv',\r\n mimetype='text/csv',\r\n attachment_filename='output_LPC.csv',\r\n as_attachment=True)\r\n\r\n# function that reads the test.csv and creates dataframe from which a filtered dataframe is generated which contains all the metabolics with suffix as plasmalogen and later write it a file\r\[email protected]('/metabolic_suffix_plasmalogen')\r\ndef metabolic_suffix_plasmalogen():\r\n column_names = pd.read_csv('input/test.csv', engine='python')\r\n columns=list(column_names.columns.values)\r\n dict={}\r\n for i in range(len(columns)):\r\n dict[i]=columns[i]\r\n\r\n\r\n csv_df = pd.read_csv('input/test.csv', header=None, skiprows=1, engine='python')\r\n child_dataset3 = csv_df[csv_df[2].str.endswith('plasmalogen', na=False)]\r\n child_dataset3.rename(columns=dict,inplace=True)\r\n tfile = open('outputs/output_plasmalogen.csv', 'w')\r\n tfile.write(child_dataset3.to_string())\r\n tfile.close()\r\n return send_file('outputs/output_plasmalogen.csv',\r\n mimetype='text/csv',\r\n attachment_filename='output_plasmalogen.csv',\r\n as_attachment=True)\r\n# function that appends the Retention Time Roundoff column in the main dataframe and later write it a file\r\[email protected]('/parentfile_with_RTR')\r\ndef parentfile_with_RTR():\r\n column_names = pd.read_csv('input/test.csv', engine='python')\r\n columns=list(column_names.columns.values)\r\n dict={}\r\n for i in range(len(columns)):\r\n dict[i]=columns[i]\r\n\r\n\r\n csv_df = pd.read_csv('input/test.csv', header=None, skiprows=1, engine='python')\r\n csv_df[1050] = round(csv_df[1])\r\n csv_df.rename(columns={1050:'Retention Time Roundoff(in mins)'}, inplace=True)\r\n csv_df.rename(columns=dict,inplace=True)\r\n tfile = open('outputs/outputfile_with_RTR.csv', 'w')\r\n tfile.write(csv_df.to_string())\r\n tfile.close()\r\n return send_file('outputs/outputfile_with_RTR.csv',\r\n mimetype='text/csv',\r\n attachment_filename='outputfile_with_RTR.csv',\r\n as_attachment=True)\r\n# function that creates a dataframe that has mean of all metabolics readings grouped by Retention Time Roundoff(in mins) and these dataframe doesnot include unnecessary columns and finally it is written to the file\r\[email protected]('/metabolicmean_with_similarRTR')\r\ndef metabolicmean_with_similarRTR():\r\n column_names = pd.read_csv('input/test.csv', engine='python')\r\n columns=list(column_names.columns.values)\r\n dict={}\r\n for i in range(3,len(columns)):\r\n dict[i]=columns[i]\r\n csv_df = pd.read_csv('input/test.csv', header=None, skiprows=1, engine='python')\r\n csv_df[1050] = round(csv_df[1])\r\n csv_df.drop([0,1,2], axis = 1, inplace = True)\r\n csv_df.rename(columns=dict,inplace=True)\r\n\r\n\r\n\r\n csv_df.rename(columns={1050:'Retention Time Roundoff(in mins)'}, inplace=True)\r\n\r\n final =csv_df.groupby('Retention Time Roundoff(in mins)').agg('mean')\r\n\r\n tfile = open('outputs/outputfile_metabolicmean_with_similarRTR.csv', 'w')\r\n\r\n tfile.write(final.to_string())\r\n tfile.close()\r\n return send_file('outputs/outputfile_metabolicmean_with_similarRTR.csv',\r\n mimetype='text/csv',\r\n attachment_filename='outputfile_metabolicmean_with_similarRTR.csv',\r\n as_attachment=True)\r\n\r\n\r\n" ]	[ [ "pandas.read_csv" ] ]
phylatechnologies/ibd_classification_benchmark	[ "667e0b42e70bd56c6675062b10dae38407e785b0" ]	[ "run_results.py" ]	[ "import os\nimport pandas as pd\nimport numpy as np\nfrom metadata.getters import get_pwd\nfrom analysis.evaluation_methods import get_performance\nimport random\nnp.random.seed(26)\nrandom.seed(26)\ndef get_sample_info(dataset):\n '''\n :param exp_name: experiment string\n :return: unpickled data set\n '''\n\n data_file = '{}.pkl'.format(dataset)\n data_path = '{}/datasets/{}'.format(get_pwd(), data_file)\n df = pd.read_pickle(data_path)\n info = df[['diagnosis','studyID']]\n\n return info\n\nif (__name__==\"__main__\"):\n\n res_path = get_pwd() + '/results'\n res = os.listdir(res_path)\n\n\n for e in res:\n output = '{}/metrics'.format(get_pwd())\n if not os.path.isdir(output):\n os.mkdir(output)\n \n exp_name = e.split('.')[0]\n dataset = exp_name.split('-')[0]\n\n if not os.path.isfile('{}/{}.csv'.format(output, exp_name)):\n \n info = get_sample_info(dataset)\n\n file = '{}/{}'.format(res_path, e)\n\n y_pred = pd.read_csv(file, index_col=0)\n y_pred = np.round(y_pred)\n\n y = pd.concat([info, y_pred], axis = 1, sort=False)\n y.columns = ['true', 'studyID', 'pred']\n\n metrics = get_performance(y_df=y, index_name=exp_name)\n\n print(metrics)\n metrics.to_csv('{}/{}.csv'.format(output, exp_name))\n" ]	[ [ "pandas.concat", "pandas.read_csv", "numpy.random.seed", "numpy.round", "pandas.read_pickle" ] ]
Iamal1/maskrcnn-benchmark	[ "d53c1986e72c6a647179f5bf0e060db1160a1a42" ]	[ "maskrcnn_benchmark/data/datasets/coco.py" ]	[ "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\nimport torch\nimport torchvision\n\nfrom maskrcnn_benchmark.structures.bounding_box import BoxList\nfrom maskrcnn_benchmark.structures.segmentation_mask import SegmentationMask\nfrom maskrcnn_benchmark.structures.keypoint import PersonKeypoints\n\nfrom torch.distributions.beta import Beta\nfrom PIL import Image\nimport logging\nlogger = logging.getLogger(\"maskrcnn_benchmark.coco\")\nimport numpy\n\nmin_keypoints_per_image = 10\n\n\ndef _count_visible_keypoints(anno):\n return sum(sum(1 for v in ann[\"keypoints\"][2::3] if v > 0) for ann in anno)\n\n\ndef _has_only_empty_bbox(anno):\n return all(any(o <= 1 for o in obj[\"bbox\"][2:]) for obj in anno)\n\n\ndef has_valid_annotation(anno):\n # if it's empty, there is no annotation\n if len(anno) == 0:\n return False\n # if all boxes have close to zero area, there is no annotation\n if _has_only_empty_bbox(anno):\n return False\n # keypoints task have a slight different critera for considering\n # if an annotation is valid\n if \"keypoints\" not in anno[0]:\n return True\n # for keypoint detection tasks, only consider valid images those\n # containing at least min_keypoints_per_image\n if _count_visible_keypoints(anno) >= min_keypoints_per_image:\n return True\n return False\n\n\nclass COCODataset(torchvision.datasets.coco.CocoDetection):\n def __init__(\n self, ann_file, root, remove_images_without_annotations, transforms=None\n ):\n super(COCODataset, self).__init__(root, ann_file)\n # sort indices for reproducible results\n self.ids = sorted(self.ids)\n\n # filter images without detection annotations\n if remove_images_without_annotations:\n ids = []\n for img_id in self.ids:\n ann_ids = self.coco.getAnnIds(imgIds=img_id, iscrowd=None)\n anno = self.coco.loadAnns(ann_ids)\n if has_valid_annotation(anno):\n ids.append(img_id)\n self.ids = ids\n\n self.json_category_id_to_contiguous_id = {\n v: i + 1 for i, v in enumerate(self.coco.getCatIds())\n }\n self.contiguous_category_id_to_json_id = {\n v: k for k, v in self.json_category_id_to_contiguous_id.items()\n }\n self.id_to_img_map = {k: v for k, v in enumerate(self.ids)}\n self.transforms = transforms\n\n def __getitem__(self, idx):\n # '''\n # img is tensor now\n # '''\n # img_a, target_a, idx_a = self.get_one_item(idx)\n # img_b, target_b, idx_b = self.get_one_item((idx+1) % len(self.ids))\n # #merge them\n # #merge img\n # m = Beta(torch.tensor([1.5]), torch.tensor([1.5]))\n # cof_a = m.sample()\n # #cof_a = 0.5\n # c,ha,wa = img_a.shape\n # c,hb,wb = img_b.shape\n # h,w = (max(ha,hb),max(wa,wb))\n # img = img_a.new_zeros((c,h,w))\n # img[:,:ha,:wa] = cof_a * img_a\n # img[:,:hb,:wb] = (1-cof_a) * img_b\n\n # #merge labels and masks\n # boxes = torch.cat([target_a.bbox,target_b.bbox],dim=0)\n # target = BoxList(boxes, (w,h), mode=\"xyxy\")\n \n # classes = torch.cat([target_a.get_field('labels'),target_b.get_field('labels')],dim=0)\n # target.add_field(\"labels\", classes)\n\n # masks = target_a.get_field(\"masks\").instances.polygons + target_b.get_field(\"masks\").instances.polygons\n # masks = SegmentationMask(masks, (w,h), mode='poly')\n # target.add_field(\"masks\", masks)\n\n # # #add marks\n # # marks = [1]target_a.bbox.size(0) + [0] target_b.bbox.size(0)\n # # target.add_field(\"marks\", torch.tensor(marks))\n # cofs = [cof_a]target_a.bbox.size(0) + [1-cof_a] target_b.bbox.size(0)\n # target.add_field('cofs',torch.tensor(cofs))\n \n # return img, target, idx\n\n # def get_one_item(self, idx):\n img, anno = super(COCODataset, self).__getitem__(idx)\n\n # filter crowd annotations\n # TODO might be better to add an extra field\n anno = [obj for obj in anno if obj[\"iscrowd\"] == 0]\n\n boxes = [obj[\"bbox\"] for obj in anno]\n boxes = torch.as_tensor(boxes).reshape(-1, 4) # guard against no boxes\n target = BoxList(boxes, img.size, mode=\"xywh\").convert(\"xyxy\")\n\n classes = [obj[\"category_id\"] for obj in anno]\n classes = [self.json_category_id_to_contiguous_id[c] for c in classes]\n classes = torch.tensor(classes)\n target.add_field(\"labels\", classes)\n\n masks = [obj[\"segmentation\"] for obj in anno]\n masks = SegmentationMask(masks, img.size, mode='poly')\n target.add_field(\"masks\", masks)\n\n if anno and \"keypoints\" in anno[0]:\n keypoints = [obj[\"keypoints\"] for obj in anno]\n keypoints = PersonKeypoints(keypoints, img.size)\n target.add_field(\"keypoints\", keypoints)\n\n target = target.clip_to_image(remove_empty=True)\n\n if self.transforms is not None:\n img, target = self.transforms(img, target)\n\n return img, target, idx\n\n def get_img_info(self, index):\n img_id = self.id_to_img_map[index]\n img_data = self.coco.imgs[img_id]\n return img_data\n" ]	[ [ "torch.as_tensor", "torch.tensor" ] ]
wenh06/yolov4_acne_torch	[ "8eda65ff6805ec313de39c74aea12a774657f3ff" ]	[ "train_acne.py" ]	[ "# -- coding: utf-8 --\n'''\ntrain acne detector using the enhanced ACNE04 dataset\n\nMore reference:\n[1] https://pytorch.org/tutorials/intermediate/torchvision_tutorial.html\n'''\nimport time\nimport logging\nimport os, sys\nimport argparse\nfrom collections import deque\nimport datetime\n\nimport cv2\nfrom tqdm import tqdm\nimport numpy as np\nimport torch\nimport torch.nn as nn\nfrom torch.utils.data import DataLoader\nfrom torch import optim\nfrom torch.nn import functional as F\nfrom tensorboardX import SummaryWriter\nfrom easydict import EasyDict as ED\n\nfrom dataset_acne04 import ACNE04\nfrom cfg_acne04 import Cfg\nfrom models import Yolov4\nfrom tool.utils_iou import (\n bboxes_iou, bboxes_giou, bboxes_diou, bboxes_ciou,\n)\nfrom tool.utils import post_processing, plot_boxes_cv2\n# from tool.tv_reference.utils import MetricLogger\nfrom tool.tv_reference.utils import collate_fn as val_collate\nfrom tool.tv_reference.coco_utils import convert_to_coco_api\nfrom tool.tv_reference.coco_eval import CocoEvaluator\n\n\nDAS = True\n\n\nclass Yolo_loss(nn.Module):\n def __init__(self, n_classes=1, n_anchors=3, device=None, batch=2, iou_type='iou'):\n super(Yolo_loss, self).__init__()\n self.device = device\n self.strides = [8, 16, 32]\n image_size = 608\n self.n_classes = n_classes\n self.n_anchors = n_anchors\n self.iou_type = iou_type\n\n self.anchors = [[12, 16], [19, 36], [40, 28], [36, 75], [76, 55], [72, 146], [142, 110], [192, 243], [459, 401]]\n # self.anchors = [[7, 7], [8, 9], [10, 8], [11, 10], [11, 12], [13, 17], [14, 11], [16, 14], [20, 21]]\n self.anch_masks = [[0, 1, 2], [3, 4, 5], [6, 7, 8]]\n self.ignore_thre = 0.5\n\n self.masked_anchors, self.ref_anchors, self.grid_x, self.grid_y, self.anchor_w, self.anchor_h = [], [], [], [], [], []\n\n for i in range(3):\n all_anchors_grid = [(w / self.strides[i], h / self.strides[i]) for w, h in self.anchors]\n masked_anchors = np.array([all_anchors_grid[j] for j in self.anch_masks[i]], dtype=np.float32)\n ref_anchors = np.zeros((len(all_anchors_grid), 4), dtype=np.float32)\n ref_anchors[:, 2:] = np.array(all_anchors_grid, dtype=np.float32)\n ref_anchors = torch.from_numpy(ref_anchors)\n # calculate pred - xywh obj cls\n fsize = image_size // self.strides[i]\n grid_x = torch.arange(fsize, dtype=torch.float).repeat(batch, 3, fsize, 1).to(device)\n grid_y = torch.arange(fsize, dtype=torch.float).repeat(batch, 3, fsize, 1).permute(0, 1, 3, 2).to(device)\n anchor_w = torch.from_numpy(masked_anchors[:, 0]).repeat(batch, fsize, fsize, 1).permute(0, 3, 1, 2).to(\n device)\n anchor_h = torch.from_numpy(masked_anchors[:, 1]).repeat(batch, fsize, fsize, 1).permute(0, 3, 1, 2).to(\n device)\n\n self.masked_anchors.append(masked_anchors)\n self.ref_anchors.append(ref_anchors)\n self.grid_x.append(grid_x)\n self.grid_y.append(grid_y)\n self.anchor_w.append(anchor_w)\n self.anchor_h.append(anchor_h)\n\n def build_target(self, pred, labels, batchsize, fsize, n_ch, output_id):\n # target assignment\n tgt_mask = torch.zeros(batchsize, self.n_anchors, fsize, fsize, 4 + self.n_classes).to(device=self.device)\n obj_mask = torch.ones(batchsize, self.n_anchors, fsize, fsize).to(device=self.device)\n tgt_scale = torch.zeros(batchsize, self.n_anchors, fsize, fsize, 2).to(self.device)\n target = torch.zeros(batchsize, self.n_anchors, fsize, fsize, n_ch).to(self.device)\n\n # labels = labels.cpu().data\n nlabel = (labels.sum(dim=2) > 0).sum(dim=1) # number of objects\n\n truth_x_all = (labels[:, :, 2] + labels[:, :, 0]) / (self.strides[output_id] * 2)\n truth_y_all = (labels[:, :, 3] + labels[:, :, 1]) / (self.strides[output_id] * 2)\n truth_w_all = (labels[:, :, 2] - labels[:, :, 0]) / self.strides[output_id]\n truth_h_all = (labels[:, :, 3] - labels[:, :, 1]) / self.strides[output_id]\n truth_i_all = truth_x_all.to(torch.int16).cpu().numpy()\n truth_j_all = truth_y_all.to(torch.int16).cpu().numpy()\n\n for b in range(batchsize):\n n = int(nlabel[b])\n if n == 0:\n continue\n truth_box = torch.zeros(n, 4).to(self.device)\n truth_box[:n, 2] = truth_w_all[b, :n]\n truth_box[:n, 3] = truth_h_all[b, :n]\n truth_i = truth_i_all[b, :n]\n truth_j = truth_j_all[b, :n]\n\n # calculate iou between truth and reference anchors\n # anchor_ious_all = bboxes_iou(truth_box.cpu(), self.ref_anchors[output_id])\n anchor_ious_all = bboxes_iou(\n truth_box.cpu(),\n self.ref_anchors[output_id],\n fmt='voc',\n # iou_type='iou',\n iou_type=self.iou_type,\n )\n best_n_all = anchor_ious_all.argmax(dim=1)\n best_n = best_n_all % 3\n best_n_mask = ((best_n_all == self.anch_masks[output_id][0]) \|\n (best_n_all == self.anch_masks[output_id][1]) \|\n (best_n_all == self.anch_masks[output_id][2]))\n\n if sum(best_n_mask) == 0:\n continue\n\n truth_box[:n, 0] = truth_x_all[b, :n]\n truth_box[:n, 1] = truth_y_all[b, :n]\n\n # pred_ious = bboxes_iou(pred[b].view(-1, 4), truth_box, xyxy=False)\n pred_ious = bboxes_iou(\n pred[b].view(-1, 4),\n truth_box,\n fmt='yolo',\n # iou_type='iou',\n iou_type=self.iou_type,\n )\n pred_best_iou, _ = pred_ious.max(dim=1)\n pred_best_iou = (pred_best_iou > self.ignore_thre)\n pred_best_iou = pred_best_iou.view(pred[b].shape[:3])\n # set mask to zero (ignore) if pred matches truth\n obj_mask[b] = ~ pred_best_iou\n\n for ti in range(best_n.shape[0]):\n if best_n_mask[ti] == 1:\n i, j = truth_i[ti], truth_j[ti]\n a = best_n[ti]\n obj_mask[b, a, j, i] = 1\n tgt_mask[b, a, j, i, :] = 1\n target[b, a, j, i, 0] = truth_x_all[b, ti] - truth_x_all[b, ti].to(torch.int16).to(torch.float)\n target[b, a, j, i, 1] = truth_y_all[b, ti] - truth_y_all[b, ti].to(torch.int16).to(torch.float)\n target[b, a, j, i, 2] = torch.log(\n truth_w_all[b, ti] / torch.Tensor(self.masked_anchors[output_id])[best_n[ti], 0] + 1e-16)\n target[b, a, j, i, 3] = torch.log(\n truth_h_all[b, ti] / torch.Tensor(self.masked_anchors[output_id])[best_n[ti], 1] + 1e-16)\n target[b, a, j, i, 4] = 1\n target[b, a, j, i, 5 + labels[b, ti, 4].to(torch.int16).cpu().numpy()] = 1\n tgt_scale[b, a, j, i, :] = torch.sqrt(2 - truth_w_all[b, ti] * truth_h_all[b, ti] / fsize / fsize)\n return obj_mask, tgt_mask, tgt_scale, target\n\n def forward(self, xin, labels=None):\n loss, loss_xy, loss_wh, loss_obj, loss_cls, loss_l2 = 0, 0, 0, 0, 0, 0\n for output_id, output in enumerate(xin):\n batchsize = output.shape[0]\n fsize = output.shape[2]\n n_ch = 5 + self.n_classes\n\n output = output.view(batchsize, self.n_anchors, n_ch, fsize, fsize)\n output = output.permute(0, 1, 3, 4, 2) # .contiguous()\n\n # logistic activation for xy, obj, cls\n output[..., np.r_[:2, 4:n_ch]] = torch.sigmoid(output[..., np.r_[:2, 4:n_ch]])\n\n pred = output[..., :4].clone()\n pred[..., 0] += self.grid_x[output_id]\n pred[..., 1] += self.grid_y[output_id]\n pred[..., 2] = torch.exp(pred[..., 2]) * self.anchor_w[output_id]\n pred[..., 3] = torch.exp(pred[..., 3]) * self.anchor_h[output_id]\n\n obj_mask, tgt_mask, tgt_scale, target = self.build_target(\n pred, labels, batchsize, fsize, n_ch, output_id\n )\n\n # loss calculation\n output[..., 4] = obj_mask\n output[..., np.r_[0:4, 5:n_ch]] = tgt_mask\n output[..., 2:4] = tgt_scale\n\n target[..., 4] = obj_mask\n target[..., np.r_[0:4, 5:n_ch]] = tgt_mask\n target[..., 2:4] = tgt_scale\n\n loss_xy += F.binary_cross_entropy(\n input=output[..., :2],\n target=target[..., :2],\n weight=tgt_scaletgt_scale,\n size_average=False,\n )\n loss_wh += F.mse_loss(input=output[..., 2:4], target=target[..., 2:4], size_average=False) / 2\n loss_obj += F.binary_cross_entropy(input=output[..., 4], target=target[..., 4], size_average=False)\n loss_cls += F.binary_cross_entropy(input=output[..., 5:], target=target[..., 5:], size_average=False)\n loss_l2 += F.mse_loss(input=output, target=target, size_average=False)\n\n loss = loss_xy + loss_wh + loss_obj + loss_cls\n\n return loss, loss_xy, loss_wh, loss_obj, loss_cls, loss_l2\n\n\ndef collate(batch):\n images = []\n bboxes = []\n for img, box in batch:\n images.append([img])\n bboxes.append([box])\n images = np.concatenate(images, axis=0)\n images = images.transpose(0, 3, 1, 2)\n images = torch.from_numpy(images).div(255.0)\n bboxes = np.concatenate(bboxes, axis=0)\n bboxes = torch.from_numpy(bboxes)\n return images, bboxes\n\n\ndef train(model, device, config, epochs=5, batch_size=1, save_ckpt=True, log_step=20, logger=None, img_scale=0.5):\n \"\"\"\n \"\"\"\n train_dataset = ACNE04(label_path=config.train_label, cfg=config, train=True)\n val_dataset = ACNE04(label_path=config.val_label, cfg=config, train=False)\n\n n_train = len(train_dataset)\n n_val = len(val_dataset)\n\n train_loader = DataLoader(\n dataset=train_dataset,\n batch_size=config.batch // config.subdivisions,\n shuffle=True,\n num_workers=8,\n pin_memory=True,\n drop_last=True, # setting False would result in error\n collate_fn=collate,\n )\n\n val_loader = DataLoader(\n dataset=val_dataset,\n batch_size=config.batch // config.subdivisions,\n shuffle=True,\n num_workers=8,\n pin_memory=True,\n drop_last=True, # setting False would result in error\n collate_fn=val_collate,\n )\n\n writer = SummaryWriter(\n log_dir=config.TRAIN_TENSORBOARD_DIR,\n filename_suffix=f'OPT_{config.TRAIN_OPTIMIZER}_LR_{config.learning_rate}_BS_{config.batch}_Sub_{config.subdivisions}_Size_{config.width}',\n comment=f'OPT_{config.TRAIN_OPTIMIZER}_LR_{config.learning_rate}_BS_{config.batch}_Sub_{config.subdivisions}_Size_{config.width}',\n )\n \n max_itr = config.TRAIN_EPOCHS n_train\n # global_step = cfg.TRAIN_MINEPOCH * n_train\n global_step = 0\n if logger:\n logger.info(f'''Starting training:\n Epochs: {epochs}\n Batch size: {config.batch}\n Subdivisions: {config.subdivisions}\n Learning rate: {config.learning_rate}\n Training size: {n_train}\n Validation size: {n_val}\n Checkpoints: {save_ckpt}\n Device: {device.type}\n Images size: {config.width}\n Optimizer: {config.TRAIN_OPTIMIZER}\n Dataset classes: {config.classes}\n Train label path:{config.train_label}\n Pretrained: {config.pretrained}\n ''')\n\n # learning rate setup\n def burnin_schedule(i):\n if i < config.burn_in:\n factor = pow(i / config.burn_in, 4)\n elif i < config.steps[0]:\n factor = 1.0\n elif i < config.steps[1]:\n factor = 0.1\n else:\n factor = 0.01\n return factor\n\n if config.TRAIN_OPTIMIZER.lower() == 'adam':\n optimizer = optim.Adam(\n params=model.parameters(),\n lr=config.learning_rate / config.batch,\n betas=(0.9, 0.999),\n eps=1e-08,\n )\n elif config.TRAIN_OPTIMIZER.lower() == 'sgd':\n optimizer = optim.SGD(\n params=model.parameters(),\n lr=config.learning_rate / config.batch,\n momentum=config.momentum,\n weight_decay=config.decay,\n )\n scheduler = optim.lr_scheduler.LambdaLR(optimizer, burnin_schedule)\n\n criterion = Yolo_loss(\n n_classes=config.classes,\n device=device,\n batch=config.batch // config.subdivisions,\n iou_type=config.iou_type,\n )\n # scheduler = ReduceLROnPlateau(optimizer, mode='max', verbose=True, patience=6, min_lr=1e-7)\n # scheduler = CosineAnnealingWarmRestarts(optimizer, 0.001, 1e-6, 20)\n\n save_prefix = 'Yolov4_epoch'\n saved_models = deque()\n model.train()\n\n for epoch in range(epochs):\n model.train()\n epoch_loss = 0\n epoch_step = 0\n\n with tqdm(total=n_train, desc=f'Epoch {epoch + 1}/{epochs}', unit='img', ncols=100) as pbar:\n for i, batch in enumerate(train_loader):\n global_step += 1\n epoch_step += 1\n images = batch[0]\n bboxes = batch[1]\n\n images = images.to(device=device, dtype=torch.float32)\n bboxes = bboxes.to(device=device)\n\n bboxes_pred = model(images)\n loss, loss_xy, loss_wh, loss_obj, loss_cls, loss_l2 = criterion(bboxes_pred, bboxes)\n # loss = loss / config.subdivisions\n loss.backward()\n\n epoch_loss += loss.item()\n\n if global_step % config.subdivisions == 0:\n optimizer.step()\n scheduler.step()\n model.zero_grad()\n\n if global_step % (log_step * config.subdivisions) == 0:\n writer.add_scalar('train/Loss', loss.item(), global_step)\n writer.add_scalar('train/loss_xy', loss_xy.item(), global_step)\n writer.add_scalar('train/loss_wh', loss_wh.item(), global_step)\n writer.add_scalar('train/loss_obj', loss_obj.item(), global_step)\n writer.add_scalar('train/loss_cls', loss_cls.item(), global_step)\n writer.add_scalar('train/loss_l2', loss_l2.item(), global_step)\n writer.add_scalar('lr', scheduler.get_lr()[0] * config.batch, global_step)\n pbar.set_postfix(*{\n 'loss (batch)': loss.item(),\n 'loss_xy': loss_xy.item(),\n 'loss_wh': loss_wh.item(),\n 'loss_obj': loss_obj.item(),\n 'loss_cls': loss_cls.item(),\n 'loss_l2': loss_l2.item(),\n 'lr': scheduler.get_lr()[0] config.batch\n })\n if logger:\n logger.info(f'Train step_{global_step}: loss : {loss.item()},loss xy : {loss_xy.item()}, loss wh : {loss_wh.item()}, loss obj : {loss_obj.item()}, loss cls : {loss_cls.item()}, loss l2 : {loss_l2.item()}, lr : {scheduler.get_lr()[0] * config.batch}')\n\n pbar.update(images.shape[0])\n \n # TODO: eval for each epoch using `evaluate`\n eval_model = Yolov4(yolov4conv137weight=None, n_classes=config.classes, inference=True)\n eval_model.load_state_dict(model.state_dict())\n eval_model.to(device)\n evaluator = evaluate(eval_model, val_loader, config, device, logger)\n del eval_model\n\n stats = evaluator.coco_eval['bbox'].stats\n writer.add_scalar('train/AP', stats[0], global_step)\n writer.add_scalar('train/AP50', stats[1], global_step)\n writer.add_scalar('train/AP75', stats[2], global_step)\n writer.add_scalar('train/AP_small', stats[3], global_step)\n writer.add_scalar('train/AP_medium', stats[4], global_step)\n writer.add_scalar('train/AP_large', stats[5], global_step)\n writer.add_scalar('train/AR1', stats[6], global_step)\n writer.add_scalar('train/AR10', stats[7], global_step)\n writer.add_scalar('train/AR100', stats[8], global_step)\n writer.add_scalar('train/AR_small', stats[9], global_step)\n writer.add_scalar('train/AR_medium', stats[10], global_step)\n writer.add_scalar('train/AR_large', stats[11], global_step)\n\n if save_ckpt:\n try:\n os.mkdir(config.checkpoints)\n if logger:\n logger.info('Created checkpoint directory')\n except OSError:\n pass\n save_path = os.path.join(config.checkpoints, f'{save_prefix}{epoch + 1}_{_get_date_str()}.pth')\n torch.save(model.state_dict(), save_path)\n if logger:\n logger.info(f'Checkpoint {epoch + 1} saved!')\n saved_models.append(save_path)\n # remove outdated models\n if len(saved_models) > config.keep_checkpoint_max > 0:\n model_to_remove = saved_models.popleft()\n try:\n os.remove(model_to_remove)\n except:\n logger.info(f'failed to remove {model_to_remove}')\n\n writer.close()\n\n\[email protected]_grad()\ndef evaluate(model, data_loader, cfg, device, logger=None, *kwargs):\n \"\"\" finished, tested\n \"\"\"\n # cpu_device = torch.device(\"cpu\")\n model.eval()\n # header = 'Test:'\n\n coco = convert_to_coco_api(data_loader.dataset, bbox_fmt='coco')\n coco_evaluator = CocoEvaluator(coco, iou_types = [\"bbox\"], bbox_fmt='coco')\n\n for images, targets in data_loader:\n model_input = [[cv2.resize(img, (cfg.w, cfg.h))] for img in images]\n model_input = np.concatenate(model_input, axis=0)\n model_input = model_input.transpose(0, 3, 1, 2)\n model_input = torch.from_numpy(model_input).div(255.0)\n model_input = model_input.to(device)\n targets = [{k: v.to(device) for k, v in t.items()} for t in targets]\n\n if torch.cuda.is_available():\n torch.cuda.synchronize()\n model_time = time.time()\n outputs = model(model_input)\n\n # outputs = [{k: v.to(cpu_device) for k, v in t.items()} for t in outputs]\n model_time = time.time() - model_time\n\n # outputs = outputs.cpu().detach().numpy()\n res = {}\n # for img, target, output in zip(images, targets, outputs):\n for img, target, boxes, confs in zip(images, targets, outputs[0], outputs[1]):\n img_height, img_width = img.shape[:2]\n # boxes = output[...,:4].copy() # output boxes in yolo format\n boxes = boxes.squeeze(2).cpu().detach().numpy()\n boxes[...,2:] = boxes[...,2:] - boxes[...,:2] # Transform [x1, y1, x2, y2] to [x1, y1, w, h]\n boxes[...,0] = boxes[...,0]img_width\n boxes[...,1] = boxes[...,1]img_height\n boxes[...,2] = boxes[...,2]img_width\n boxes[...,3] = boxes[...,3]img_height\n boxes = torch.as_tensor(boxes, dtype=torch.float32)\n # confs = output[...,4:].copy()\n confs = confs.cpu().detach().numpy()\n labels = np.argmax(confs, axis=1).flatten()\n labels = torch.as_tensor(labels, dtype=torch.int64)\n scores = np.max(confs, axis=1).flatten()\n scores = torch.as_tensor(scores, dtype=torch.float32)\n res[target[\"image_id\"].item()] = {\n \"boxes\": boxes,\n \"scores\": scores,\n \"labels\": labels,\n }\n\n debug = kwargs.get(\"debug\", [])\n if isinstance(debug, str):\n debug = [debug]\n debug = [item.lower() for item in debug]\n if 'iou' in debug:\n from tool.utils_iou_test import bboxes_iou_test\n ouput_boxes = np.array(post_processing(None, 0.5, 0.5, outputs)[0])[...,:4]\n img_height, img_width = images[0].shape[:2]\n ouput_boxes[...,0] = ouput_boxes[...,0] img_width\n ouput_boxes[...,1] = ouput_boxes[...,1] * img_height\n ouput_boxes[...,2] = ouput_boxes[...,2] * img_width\n ouput_boxes[...,3] = ouput_boxes[...,3] * img_height\n # coco format to yolo format\n truth_boxes = targets[0]['boxes'].numpy().copy()\n truth_boxes[...,:2] = truth_boxes[...,:2] + truth_boxes[...,2:]/2\n iou = bboxes_iou_test(torch.Tensor(ouput_boxes), torch.Tensor(truth_boxes), fmt='yolo')\n print(f\"iou of first image = {iou}\")\n if len(debug) > 0:\n return\n \n evaluator_time = time.time()\n coco_evaluator.update(res)\n evaluator_time = time.time() - evaluator_time\n\n # gather the stats from all processes\n coco_evaluator.synchronize_between_processes()\n\n # accumulate predictions from all images\n coco_evaluator.accumulate()\n coco_evaluator.summarize()\n\n return coco_evaluator\n\n\ndef get_args(kwargs):\n \"\"\"\n \"\"\"\n pretrained_detector = '/mnt/wenhao71/workspace/yolov4_acne_torch/pretrained/yolov4.pth'\n cfg = kwargs\n parser = argparse.ArgumentParser(\n description='Train the Model on images and target masks',\n formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n # parser.add_argument(\n # '-b', '--batch-size',\n # metavar='B', type=int, nargs='?', default=2,\n # help='Batch size',\n # dest='batchsize')\n parser.add_argument(\n '-l', '--learning-rate',\n metavar='LR', type=float, nargs='?', default=0.001,\n help='Learning rate',\n dest='learning_rate')\n parser.add_argument(\n '-f', '--load',\n dest='load', type=str, default=pretrained_detector,\n help='Load model from a .pth file')\n parser.add_argument(\n '-g', '--gpu',\n metavar='G', type=str, default='0',\n help='GPU',\n dest='gpu')\n # `dataset_dir` and `pretrained` already set in cfg_acne04.py\n # parser.add_argument(\n # '-dir', '--data-dir',\n # type=str, default=None,\n # help='dataset dir', dest='dataset_dir')\n # parser.add_argument(\n # '-pretrained',\n # type=str, default=None,\n # help='pretrained yolov4.conv.137')\n parser.add_argument(\n '-classes',\n type=int, default=1,\n help='dataset classes')\n # parser.add_argument(\n # '-train_label_path',\n # dest='train_label', type=str, default='train.txt',\n # help=\"train label path\")\n parser.add_argument(\n '-iou-type', type=str, default='iou',\n help='iou type (iou, giou, diou, ciou)',\n dest='iou_type')\n parser.add_argument(\n '-keep-checkpoint-max', type=int, default=10,\n help='maximum number of checkpoints to keep. If set 0, all checkpoints will be kept',\n dest='keep_checkpoint_max')\n parser.add_argument(\n '-optimizer', type=str, default='adam',\n help='training optimizer',\n dest='TRAIN_OPTIMIZER')\n \n args = vars(parser.parse_args())\n\n cfg.update(args)\n \n return ED(cfg)\n\n\ndef init_logger(log_file=None, log_dir=None, mode='a', verbose=0):\n \"\"\"\n \"\"\"\n if log_dir is None:\n log_dir = '~/temp/log/'\n if log_file is None:\n log_file = f'log_{_get_date_str()}.txt'\n if not os.path.exists(log_dir):\n os.makedirs(log_dir)\n log_file = os.path.join(log_dir, log_file)\n print(f'log file path: {log_file}')\n\n logger = logging.getLogger('Yolov4-ACNE04')\n\n c_handler = logging.StreamHandler(sys.stdout)\n f_handler = logging.FileHandler(log_file)\n\n if verbose >= 2:\n print(\"levels of c_handler and f_handler are set DEBUG\")\n c_handler.setLevel(logging.DEBUG)\n f_handler.setLevel(logging.DEBUG)\n logger.setLevel(logging.DEBUG)\n elif verbose >= 1:\n print(\"level of c_handler is set INFO, level of f_handler is set DEBUG\")\n c_handler.setLevel(logging.INFO)\n f_handler.setLevel(logging.DEBUG)\n logger.setLevel(logging.DEBUG)\n else:\n print(\"levels of c_handler and f_handler are set WARNING\")\n c_handler.setLevel(logging.WARNING)\n f_handler.setLevel(logging.WARNING)\n logger.setLevel(logging.WARNING)\n\n c_format = logging.Formatter('%(name)s - %(levelname)s - %(message)s')\n f_format = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')\n c_handler.setFormatter(c_format)\n f_handler.setFormatter(f_format)\n\n logger.addHandler(c_handler)\n logger.addHandler(f_handler)\n\n return logger\n\n\ndef _get_date_str():\n now = datetime.datetime.now()\n return now.strftime('%Y-%m-%d_%H-%M')\n\n\n\"\"\"\ntorch, torch vision, cu compatibility:\nhttps://download.pytorch.org/whl/torch_stable.html\nhttps://download.pytorch.org/whl/cu100/torch-1.3.1%2Bcu100-cp36-cp36m-linux_x86_64.whl\n\"\"\"\n\nif __name__ == \"__main__\":\n cfg = get_args(Cfg)\n # os.environ[\"CUDA_VISIBLE_DEVICES\"] = cfg.gpu\n if not DAS:\n device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n else:\n device = torch.device('cuda')\n log_dir = cfg.TRAIN_TENSORBOARD_DIR\n logger = init_logger(log_dir=log_dir)\n logger.info(f\"\\n{''20} Start Training {''20}\\n\")\n logger.info(f'Using device {device}')\n logger.info(f\"Using torch of version {torch.__version__}\")\n logger.info(f'with configuration {cfg}')\n print(f\"\\n{''20} Start Training {''20}\\n\")\n print(f'Using device {device}')\n print(f\"Using torch of version {torch.__version__}\")\n print(f'with configuration {cfg}')\n\n model = Yolov4(cfg.pretrained, n_classes=cfg.classes)\n\n if not DAS and torch.cuda.device_count() > 1:\n model = torch.nn.DataParallel(model)\n if not DAS:\n model.to(device=device)\n else:\n model.cuda()\n\n try:\n train(\n model=model,\n config=cfg,\n epochs=cfg.TRAIN_EPOCHS,\n device=device,\n logger=logger,\n )\n except KeyboardInterrupt:\n torch.save(model.state_dict(), os.path.join(cfg.checkpoints, 'INTERRUPTED.pth'))\n logger.info('Saved interrupt')\n try:\n sys.exit(0)\n except SystemExit:\n os._exit(0)\n" ]	[ [ "torch.optim.lr_scheduler.LambdaLR", "torch.zeros", "torch.utils.data.DataLoader", "numpy.concatenate", "numpy.max", "torch.no_grad", "torch.cuda.is_available", "torch.device", "torch.cuda.synchronize", "torch.ones", "torch.sqrt", "torch.from_numpy", "numpy.argmax", "torch.arange", "torch.sigmoid", "torch.exp", "torch.nn.functional.mse_loss", "torch.cuda.device_count", "numpy.array", "torch.as_tensor", "torch.Tensor", "torch.nn.functional.binary_cross_entropy", "torch.nn.DataParallel" ] ]
ayushmaskey/log_analysis	[ "c777f48117ec8e14845aa8d2deccc7f974ca232a" ]	[ "app/analysis/validation_cluster.py" ]	[ "import pandas as pd\nimport matplotlib.pyplot as plt\nfrom matplotlib import style\nstyle.use(\"ggplot\")\n\nfrom csv_to_pandas import csv_into_dict_of_data\nfrom wavelet_transformation import csv_into_wavelet_transformed_dict_of_dataframe\n\nfrom training_cluster import reorganize_data\n\ndef get_validation_dataset(df):\n\tcolumn_list = [col for col in df.columns if col >= '2019-03-01']\n\tdf = reorganize_data(df, column_list)\n\treturn df\n\n\ndef vaidation():\n\tdf_dict = csv_into_dict_of_data()\n\t\n\tkey_list = list(df_dict.keys())\n\tfor key in key_list:\n\t\tdf = get_validation_dataset(df_dict[key])\n\t\tdf_dict[key] = df\n\n\treturn df_dict\n\ndef test_new_df_dict():\n\tdf_dict = vaidation()\n\n\tkey_list = list(df_dict.keys())\n\tprint(key_list)\n\tfor key in key_list:\n\t\tprint(key, list(df_dict[key].columns))\n\n\nif __name__ == \"__main__\":\n\n\ttest_new_df_dict()" ]	[ [ "matplotlib.style.use" ] ]
maremun/mix-attend-break-sticks	[ "db8221447fb993194641ba781e85005180f55421" ]	[ "transformer.py" ]	[ "import torch\nimport torch.nn as nn\n\nfrom modules import Linear, PosEncoding\nfrom layers import DecoderLayer\n\nimport const\n\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n\n\ndef proj_prob_simplex(inputs):\n # project updated weights onto a probability simplex\n # see https://arxiv.org/pdf/1101.6081.pdf\n sorted_inputs, sorted_idx = torch.sort(inputs.view(-1), descending=True)\n dim = len(sorted_inputs)\n for i in reversed(range(dim)):\n t = (sorted_inputs[:i+1].sum() - 1) / (i+1)\n if sorted_inputs[i] > t:\n break\n return torch.clamp(inputs-t, min=0.0)\n\n\ndef get_attn_pad_mask(seq_q, seq_k):\n assert seq_q.dim() == 2 and seq_k.dim() == 2\n b_size, len_q = seq_q.size()\n b_size, len_k = seq_k.size()\n #pad_attn_mask = seq_k.eq(const.PAD).unsqueeze(1) # b_size x 1 x len_k\n pad_attn_mask = seq_k.eq(-1).unsqueeze(1) # b_size x 1 x len_k\n pad_attn_mask = pad_attn_mask.expand(b_size, len_q, len_k) # b_size x len_q x len_k\n return pad_attn_mask\n\n\ndef get_attn_subsequent_mask(seq):\n assert seq.dim() == 2\n attn_shape = [seq.size(1), seq.size(1)]\n subsequent_mask = torch.triu(torch.ones(attn_shape, device=device), diagonal=1).byte()\n return subsequent_mask\n\n\nclass Decoder(nn.Module):\n def __init__(self, n_layers, d_k, d_v, d_model, d_ff, n_heads,\n max_seq_len, tgt_vocab_size, dropout=0.1, weighted=False):\n super(Decoder, self).__init__()\n self.d_model = d_model\n self.tgt_emb = nn.Embedding(tgt_vocab_size, d_model) #, padding_idx=const.PAD)\n self.pos_emb = PosEncoding(max_seq_len * 10, d_model) # TODO: *10 fix\n self.dropout_emb = nn.Dropout(dropout)\n self.layer_type = DecoderLayer if not weighted else WeightedDecoderLayer\n self.layers = nn.ModuleList(\n [self.layer_type(d_k, d_v, d_model, d_ff, n_heads, dropout) for _ in range(n_layers)])\n\n \n def forward(self, dec_inputs, dec_inputs_len, enc_inputs, enc_outputs, return_attn=False):\n dec_outputs = self.tgt_emb(dec_inputs)\n dec_outputs += self.pos_emb(dec_inputs_len)\n dec_outputs = self.dropout_emb(dec_outputs)\n\n dec_self_attn_pad_mask = get_attn_pad_mask(dec_inputs, dec_inputs)\n dec_self_attn_subsequent_mask = get_attn_subsequent_mask(dec_inputs)\n\n dec_self_attn_mask = torch.gt((dec_self_attn_pad_mask + dec_self_attn_subsequent_mask), 0)\n if enc_inputs is not None:\n dec_enc_attn_pad_mask = get_attn_pad_mask(dec_inputs, enc_inputs)\n else:\n dec_enc_attn_pad_mask = None\n\n dec_self_attns, dec_enc_attns = [], []\n for layer in self.layers:\n dec_outputs, dec_self_attn, dec_enc_attn = layer(dec_outputs, enc_outputs,\n self_attn_mask=dec_self_attn_mask,\n enc_attn_mask=dec_enc_attn_pad_mask)\n if return_attn:\n dec_self_attns.append(dec_self_attn)\n dec_enc_attns.append(dec_enc_attn)\n\n return dec_outputs, dec_self_attns, dec_enc_attns\n\n\nclass LMTransformer(nn.Module):\n def __init__(self, n_layers, d_k, d_v, d_model, d_ff, n_heads,\n max_tgt_seq_len, tgt_vocab_size, dropout,\n weighted_model, share_proj_weight):\n super(LMTransformer, self).__init__()\n self.decoder = Decoder(n_layers, d_k, d_v, d_model, d_ff, n_heads,\n max_tgt_seq_len, tgt_vocab_size, dropout, weighted_model)\n self.tgt_proj = Linear(d_model, tgt_vocab_size, bias=False)\n self.weighted_model = weighted_model\n\n if share_proj_weight:\n print('Sharing target embedding and projection..')\n self.tgt_proj.weight = self.decoder.tgt_emb.weight\n\n\n def trainable_params(self):\n # Avoid updating the position encoding\n params = filter(lambda p: p[1].requires_grad, self.named_parameters())\n # Add a separate parameter group for the weighted_model\n param_groups = []\n base_params = {'params': [], 'type': 'base'}\n weighted_params = {'params': [], 'type': 'weighted'}\n for name, param in params:\n if 'w_kp' in name or 'w_a' in name:\n weighted_params['params'].append(param)\n else:\n base_params['params'].append(param)\n param_groups.append(base_params)\n param_groups.append(weighted_params)\n return param_groups\n\n \n def decode(self, dec_inputs, dec_inputs_len, enc_inputs, enc_outputs, return_attn=False):\n return self.decoder(dec_inputs, dec_inputs_len, enc_inputs, enc_outputs, return_attn)\n\n \n def forward(self, dec_inputs, dec_inputs_len, return_attn=False):\n dec_outputs, dec_self_attns, _ = \\\n self.decoder(dec_inputs, dec_inputs_len, None, None, return_attn)\n dec_logits = self.tgt_proj(dec_outputs)\n return dec_logits.view(-1, dec_logits.size(-1)), dec_self_attns\n\n \n def proj_grad(self):\n if self.weighted_model:\n for name, param in self.named_parameters():\n if 'w_kp' in name or 'w_a' in name:\n param.data = proj_prob_simplex(param.data)\n else:\n pass\n" ]	[ [ "torch.nn.Dropout", "torch.ones", "torch.nn.Embedding", "torch.cuda.is_available", "torch.clamp", "torch.gt" ] ]
christostsekouronas/academyposttestanalysis	[ "913a0c13ad0482927a323b2fb3a97a8e2ca26517" ]	[ "loadCSVdata.py" ]	[ "import pandas as pd\n\n\n\ndef loadTest(filepath):\n df = pd.read_csv(filepath)\n return df" ]	[ [ "pandas.read_csv" ] ]
juliandwain/deepmind-research	[ "eca5fe66ad770027f4dd758d3a659cd8261bace5" ]	[ "meshgraphnets/cloth_model.py" ]	[ "# Lint as: python3\n# pylint: disable=g-bad-file-header\n# Copyright 2020 DeepMind Technologies Limited. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ============================================================================\n\"\"\"Model for FlagSimple.\"\"\"\n\nimport sonnet as snt\nimport tensorflow.compat.v1 as tf\n\nimport common\nimport core_model\nimport normalization\n\nclass Model(snt.AbstractModule):\n \"\"\"Model for static cloth simulation.\"\"\"\n\n def __init__(self, learned_model, name='Model'):\n super(Model, self).__init__(name=name)\n with self._enter_variable_scope():\n self._learned_model = learned_model\n self._output_normalizer = normalization.Normalizer(\n size=3, name='output_normalizer')\n self._node_normalizer = normalization.Normalizer(\n size=3+common.NodeType.SIZE, name='node_normalizer')\n self._edge_normalizer = normalization.Normalizer(\n size=7, name='edge_normalizer') # 2D coord + 3D coord + 2length = 7\n\n def _build_graph(self, inputs, is_training):\n \"\"\"Builds input graph.\"\"\"\n # construct graph nodes\n velocity = inputs['world_pos'] - inputs['prev\|world_pos']\n node_type = tf.one_hot(inputs['node_type'][:, 0], common.NodeType.SIZE)\n node_features = tf.concat([velocity, node_type], axis=-1)\n\n # construct graph edges\n senders, receivers = common.triangles_to_edges(inputs['cells'])\n relative_world_pos = (tf.gather(inputs['world_pos'], senders) -\n tf.gather(inputs['world_pos'], receivers))\n relative_mesh_pos = (tf.gather(inputs['mesh_pos'], senders) -\n tf.gather(inputs['mesh_pos'], receivers))\n edge_features = tf.concat([\n relative_world_pos,\n tf.norm(relative_world_pos, axis=-1, keepdims=True),\n relative_mesh_pos,\n tf.norm(relative_mesh_pos, axis=-1, keepdims=True)], axis=-1)\n\n mesh_edges = core_model.EdgeSet(\n name='mesh_edges',\n features=self._edge_normalizer(edge_features, is_training),\n receivers=receivers,\n senders=senders)\n return core_model.MultiGraph(\n node_features=self._node_normalizer(node_features, is_training),\n edge_sets=[mesh_edges])\n\n def _build(self, inputs):\n graph = self._build_graph(inputs, is_training=False)\n per_node_network_output = self._learned_model(graph)\n return self._update(inputs, per_node_network_output)\n\n @snt.reuse_variables\n def loss(self, inputs):\n \"\"\"L2 loss on position.\"\"\"\n graph = self._build_graph(inputs, is_training=True)\n network_output = self._learned_model(graph)\n\n # build target acceleration\n cur_position = inputs['world_pos']\n prev_position = inputs['prev\|world_pos']\n target_position = inputs['target\|world_pos']\n target_acceleration = target_position - 2cur_position + prev_position\n target_normalized = self._output_normalizer(target_acceleration)\n\n # build loss\n loss_mask = tf.equal(inputs['node_type'][:, 0], common.NodeType.NORMAL)\n error = tf.reduce_sum((target_normalized - network_output)*2, axis=1)\n loss = tf.reduce_mean(error[loss_mask])\n return loss\n\n def _update(self, inputs, per_node_network_output):\n \"\"\"Integrate model outputs.\"\"\"\n acceleration = self._output_normalizer.inverse(per_node_network_output)\n # integrate forward\n cur_position = inputs['world_pos']\n prev_position = inputs['prev\|world_pos']\n position = 2cur_position + acceleration - prev_position\n return position\n" ]	[ [ "tensorflow.compat.v1.concat", "tensorflow.compat.v1.equal", "tensorflow.compat.v1.reduce_mean", "tensorflow.compat.v1.reduce_sum", "tensorflow.compat.v1.one_hot", "tensorflow.compat.v1.gather", "tensorflow.compat.v1.norm" ] ]
TimK1998/SemanticSynthesisForScoreBasedModels	[ "b575ab646dd5a599d173b44a3585429082d0620d" ]	[ "configs/cityscapes256.py" ]	[ "import ml_collections\nimport torch\n\n\ndef get_default_configs():\n config = ml_collections.ConfigDict()\n\n # training\n config.training = training = ml_collections.ConfigDict()\n config.training.batch_size = 8\n training.epochs = 2000\n # Time in epochs\n training.checkpoint_save_freq = 50\n training.sampling_freq = 25\n # Time in steps\n training.log_freq = 50\n training.eval_freq = 5000\n training.snapshot_sampling = True\n training.reduce_mean = False\n\n # sampling\n config.sampling = sampling = ml_collections.ConfigDict()\n sampling.n_steps_each = 1\n sampling.noise_removal = True\n sampling.probability_flow = False\n sampling.snr = 0.1\n sampling.batch_size = 1\n sampling.sampling_height = 256\n sampling.sampling_width = 512\n sampling.sem_seg_scale = 0.02\n\n # data\n config.data = data = ml_collections.ConfigDict()\n data.dataset = 'cityscapes256'\n data.image_size = 256\n data.random_flip = False\n data.n_channels = 3\n data.n_labels = 20\n data.crop_to_square = False\n\n # model\n config.model = model = ml_collections.ConfigDict()\n model.sigma_min = 0.01\n model.sigma_max = 338\n model.n_scales = 2000\n model.beta_min = 0.1\n model.beta_max = 20.\n model.dropout = 0.\n model.embedding_type = 'fourier'\n model.bilinear = True\n model.conditional = True\n\n # optimization\n config.optim = optim = ml_collections.ConfigDict()\n optim.weight_decay = 0\n optim.lr = 2e-4\n optim.beta1 = 0.9\n optim.eps = 1e-8\n optim.warmup = 5000\n optim.grad_clip = 1.\n optim.mixed_prec = True\n\n config.device = torch.device('cuda:0') if torch.cuda.is_available() else torch.device('cpu')\n\n return config\n" ]	[ [ "torch.device", "torch.cuda.is_available" ] ]
DanLuoNEU/CLASP2	[ "262fb1f151c14bfe3b1c452cdf65187d8caa10bd" ]	[ "Visualizaion/hands_association.py" ]	[ "# Build up association between hands and persons ID, \n# depending on IOU between skeleton and person bounding boxes\n# Intersection part reference: https://github.com/amdegroot/ssd.pytorch/blob/master/layers/box_utils.py#L48\n# Points to improve: \n# 1. same hands for two persons using IOU, they should be unique\n# Dan, 09/29/2019\n########## Import ##########\nimport os\nimport cv2\nimport json\nimport pickle\nimport numpy as np\nimport scipy.io as sio\nfrom progress.bar import Bar\nfrom numpy.core.records import fromarrays\n########## Configuration ##########\nfile_people = 'CLASP-DATA-102419/cam09exp2_logs_fullv1.txt'\nfile_joints = 'data/joints_all_cam09exp2_102419.pkl'\nfile_save = 'data/hands_id_cam09exp2_102419.pkl'\n# Load Person Detection result{'bbox':,\n# 'id':,\n# 'bins':\n# }\n# persons_joints: dictionary\n# {- keys: frame\n# - values: dictionary {\n# ['image_name'],string of /path/to/image\n# ['people'],list of joints\n# }\n# }\n\ndef jaccard(box_a, boxes_b):\n \"\"\"Compute the jaccard overlap of one box and a list of boxes. \n The jaccard overlap is simply the intersection over union of two boxes. \n Here we operate on person box and skeleton boxes.\n E.g.:\n A n B / A U B = A n B / (area(A) + area(B) - A n B)\n Args:\n box_a: (list) Person bounding box, Shape: [4,]\n boxes_b: (list) Skeleton bounding boxes, Shape: [num_skeletons,4]\n Return:\n jaccard overlap: (tensor) Shape: [boxes_b.size(0)]\n \"\"\"\n b_a = np.asarray(box_a)[np.newaxis,:]\n b_b = np.asarray(boxes_b)\n num_a = b_a.shape[0]\n num_b = b_b.shape[0]\n min_xy_a = np.repeat(np.expand_dims(b_a[:,:2], 1),num_b,axis=1)\n min_xy_b = np.repeat(np.expand_dims(b_b[:,:2], 0),num_a,axis=0)\n max_xy_a = np.repeat(np.expand_dims(b_a[:,2:], 1),num_b,axis=1)\n max_xy_b = np.repeat(np.expand_dims(b_b[:,2:], 0),num_a,axis=0)\n min_xy = np.maximum(min_xy_a, min_xy_b) \n max_xy = np.minimum(max_xy_a, max_xy_b)\n \n inter_xy = np.clip((max_xy - min_xy), 0, np.inf)\n inter = inter_xy[:,:,0] * inter_xy[:,:,1]\n area_a = np.repeat(np.expand_dims(((b_a[:, 2]-b_a[:, 0]) * (b_a[:, 3]-b_a[:, 1])), 1),num_b,axis=1)\n area_b = np.repeat(np.expand_dims(((b_b[:, 2]-b_b[:, 0]) * (b_b[:, 3]-b_b[:, 1])), 0),num_a,axis=0)\n union = area_a + area_b - inter\n\n return (inter/union)[0,:]\n\n\ndef main():\n # Load persons data\n with open(file_people, 'r') as f:\n # frame, id, x1,y1,x2,y2\n lines = f.readlines()\n persons = {'id':{}, 'bbox':{},'bins':{},'hands':{}}\n for line in lines:\n splitted = line.split(',')\n frame_num = int(splitted[0])\n pid = splitted[1]\n x1 = int(splitted[2])\n y1 = int(splitted[3])\n x2 = int(splitted[4])\n y2 = int(splitted[5])\n\n if(frame_num not in persons['id'].keys()):\n persons['id'][frame_num] = []\n persons['bbox'][frame_num] = []\n persons['hands'][frame_num] = []\n persons['bins'][frame_num] = []\n\n persons['id'][frame_num].append(pid)\n persons['bbox'][frame_num].append([x1,y1,x2,y2])\n persons['hands'][frame_num].append([])\n persons['bins'][frame_num].append([])\n\n # # Load joints estimation results, .mat file\n # joints_mat = sio.loadmat(joints_path)\n # skeletons = joints_mat['people'][0]\n # Load joints estimation results, .pkl file\n with open( file_joints, 'rb') as f:\n persons_joints = pickle.load(f)\n\n # For every frame, for every person bbox, for every skeleton\n # compute IOU between person bbox and skeleton bbox\n # Attach hands info to persons data\n bar = Bar('Processing hands association:', max=len(persons['id']))\n for frame_id in persons['id'].keys():\n # Build bounding box for each skeleton\n # REMEMBER to filter the (0,0) joints\n bboxes_skeleton = []\n if len(persons_joints[frame_id]['people']) == 0:\n bar.next()\n continue\n for skeleton in persons_joints[frame_id]['people']:\n ## Avoid that (0,0) point is always the top left point\n for joint in skeleton:\n if joint[0] != 0 and joint[1] != 0:\n x_min, x_max = joint[0],joint[0] \n y_min, y_max = joint[1],joint[1]\n for joint in skeleton:\n if joint[0] != 0 and joint[1] != 0:\n if joint[0] < x_min: x_min = joint[0]\n elif joint[0] > x_max: x_max = joint[0]\n \n if joint[1] < y_min: y_min = joint[1]\n elif joint[1] > y_max: y_max = joint[1]\n bboxes_skeleton.append([int(x_min), int(y_min), int(x_max), int(y_max)])\n # Find the skeleton with largest IOU with the person bounding box\n for ind in range(len(persons['bbox'][frame_id])):\n bbox = persons['bbox'][frame_id][ind]\n # compute IOU\n IOUs = jaccard(bbox, bboxes_skeleton)\n skeleton_id = np.argmax(IOUs)\n if IOUs[skeleton_id] != 0:\n persons['hands'][frame_id][ind]=(persons_joints[frame_id]['people'][skeleton_id][[4,7]]).astype(int)\n bar.next()\n bar.finish()\n\n # # Test if hands in person bounding box \n # for frame_id in persons['id'].keys():\n # print(persons['hands'][frame_id],persons['bbox'][frame_id]) \n \n # Save using pickle, success\n with open(file_save,'wb') as f:\n pickle.dump(persons, f)\n\n # # Test if save the right file \n # with open(file_save,'r') as f:\n # persons = pickle.load(f) \n\n print(\"Well Done!\")\n\n\nif __name__ == \"__main__\":\n main()" ]	[ [ "numpy.expand_dims", "numpy.maximum", "numpy.minimum", "numpy.clip", "numpy.asarray", "numpy.argmax" ] ]
Bpowers4/turicreate	[ "73dad213cc1c4f74337b905baea2b3a1e5a0266c" ]	[ "src/python/turicreate/toolkits/drawing_classifier/_tf_drawing_classifier.py" ]	[ "# -- coding: utf-8 --\n# Copyright © 2019 Apple Inc. All rights reserved.\n#\n# Use of this source code is governed by a BSD-3-clause license that can\n# be found in the LICENSE.txt file or at https://opensource.org/licenses/BSD-3-Clause\nfrom __future__ import print_function as _\nfrom __future__ import division as _\nfrom __future__ import absolute_import as _\n\nimport numpy as _np\nfrom .._tf_model import TensorFlowModel\nimport turicreate.toolkits._tf_utils as _utils\nimport tensorflow.compat.v1 as _tf\n\n# This toolkit is compatible with TensorFlow V2 behavior.\n# However, until all toolkits are compatible, we must call `disable_v2_behavior()`.\n_tf.disable_v2_behavior()\n\n\nclass DrawingClassifierTensorFlowModel(TensorFlowModel):\n def __init__(self, net_params, batch_size, num_classes):\n \"\"\"\n Defines the TensorFlow model, loss, optimisation and accuracy. Then\n loads the weights into the model.\n \"\"\"\n self.gpu_policy = _utils.TensorFlowGPUPolicy()\n self.gpu_policy.start()\n\n for key in net_params.keys():\n net_params[key] = _utils.convert_shared_float_array_to_numpy(\n net_params[key]\n )\n\n self.dc_graph = _tf.Graph()\n self.num_classes = num_classes\n self.batch_size = batch_size\n self.sess = _tf.Session(graph=self.dc_graph)\n with self.dc_graph.as_default():\n self.init_drawing_classifier_graph(net_params)\n\n def init_drawing_classifier_graph(self, net_params):\n\n self.input = _tf.placeholder(_tf.float32, [self.batch_size, 28, 28, 1])\n self.weights = _tf.placeholder(_tf.float32, [self.batch_size, 1])\n self.labels = _tf.placeholder(_tf.int64, [self.batch_size, 1])\n\n # One hot encoding target\n reshaped_labels = _tf.reshape(self.labels, [self.batch_size])\n one_hot_labels = _tf.one_hot(reshaped_labels, depth=self.num_classes, axis=-1)\n\n # Reshaping weights\n reshaped_weights = _tf.reshape(self.weights, [self.batch_size])\n\n self.one_hot_labels = _tf.placeholder(_tf.int32, [None, self.num_classes])\n\n # Weights\n weights = {\n name: _tf.Variable(\n _utils.convert_conv2d_coreml_to_tf(net_params[name]), name=name\n )\n for name in (\n \"drawing_conv0_weight\",\n \"drawing_conv1_weight\",\n \"drawing_conv2_weight\",\n )\n }\n weights[\"drawing_dense1_weight\"] = _tf.Variable(\n _utils.convert_dense_coreml_to_tf(net_params[\"drawing_dense1_weight\"]),\n name=\"drawing_dense1_weight\",\n )\n \"\"\"\n To make output of CoreML pool3 (NCHW) compatible with TF (NHWC).\n Decompose FC weights to NCHW. Transpose to NHWC. Reshape back to FC.\n \"\"\"\n coreml_128_576 = net_params[\"drawing_dense0_weight\"]\n coreml_128_576 = _np.reshape(coreml_128_576, (128, 64, 3, 3))\n coreml_128_576 = _np.transpose(coreml_128_576, (0, 2, 3, 1))\n coreml_128_576 = _np.reshape(coreml_128_576, (128, 576))\n weights[\"drawing_dense0_weight\"] = _tf.Variable(\n _np.transpose(coreml_128_576, (1, 0)), name=\"drawing_dense0_weight\"\n )\n\n # Biases\n biases = {\n name: _tf.Variable(net_params[name], name=name)\n for name in (\n \"drawing_conv0_bias\",\n \"drawing_conv1_bias\",\n \"drawing_conv2_bias\",\n \"drawing_dense0_bias\",\n \"drawing_dense1_bias\",\n )\n }\n\n conv_1 = _tf.nn.conv2d(\n self.input, weights[\"drawing_conv0_weight\"], strides=1, padding=\"SAME\"\n )\n conv_1 = _tf.nn.bias_add(conv_1, biases[\"drawing_conv0_bias\"])\n relu_1 = _tf.nn.relu(conv_1)\n pool_1 = _tf.nn.max_pool2d(\n relu_1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding=\"VALID\"\n )\n\n conv_2 = _tf.nn.conv2d(\n pool_1, weights[\"drawing_conv1_weight\"], strides=1, padding=\"SAME\"\n )\n conv_2 = _tf.nn.bias_add(conv_2, biases[\"drawing_conv1_bias\"])\n relu_2 = _tf.nn.relu(conv_2)\n pool_2 = _tf.nn.max_pool2d(\n relu_2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding=\"VALID\"\n )\n\n conv_3 = _tf.nn.conv2d(\n pool_2, weights[\"drawing_conv2_weight\"], strides=1, padding=\"SAME\"\n )\n conv_3 = _tf.nn.bias_add(conv_3, biases[\"drawing_conv2_bias\"])\n relu_3 = _tf.nn.relu(conv_3)\n pool_3 = _tf.nn.max_pool2d(\n relu_3, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding=\"VALID\"\n )\n\n # Flatten the data to a 1-D vector for the fully connected layer\n fc1 = _tf.reshape(pool_3, (-1, 576))\n fc1 = _tf.nn.xw_plus_b(\n fc1,\n weights=weights[\"drawing_dense0_weight\"],\n biases=biases[\"drawing_dense0_bias\"],\n )\n fc1 = _tf.nn.relu(fc1)\n\n out = _tf.nn.xw_plus_b(\n fc1,\n weights=weights[\"drawing_dense1_weight\"],\n biases=biases[\"drawing_dense1_bias\"],\n )\n self.predictions = _tf.nn.softmax(out)\n\n # Loss\n self.cost = _tf.losses.softmax_cross_entropy(\n logits=out,\n onehot_labels=one_hot_labels,\n weights=reshaped_weights,\n reduction=_tf.losses.Reduction.NONE,\n )\n\n # Optimizer\n self.optimizer = _tf.train.AdamOptimizer(learning_rate=0.001).minimize(\n self.cost\n )\n\n self.sess = _tf.Session()\n self.sess.run(_tf.global_variables_initializer())\n\n def __del__(self):\n self.sess.close()\n self.gpu_policy.stop()\n\n def train(self, feed_dict):\n\n for key in feed_dict.keys():\n feed_dict[key] = _utils.convert_shared_float_array_to_numpy(feed_dict[key])\n\n _, final_train_loss, final_train_output = self.sess.run(\n [self.optimizer, self.cost, self.predictions],\n feed_dict={\n self.input: feed_dict[\"input\"],\n self.labels: feed_dict[\"labels\"],\n self.weights: feed_dict[\"weights\"],\n },\n )\n\n result = {\n \"loss\": _np.array(final_train_loss),\n \"output\": _np.array(final_train_output),\n }\n\n return result\n\n def predict(self, feed_dict):\n\n is_train = \"labels\" in feed_dict\n\n for key in feed_dict.keys():\n feed_dict[key] = _utils.convert_shared_float_array_to_numpy(feed_dict[key])\n\n feed_dict_for_session = {self.input: feed_dict[\"input\"]}\n\n if is_train:\n\n feed_dict_for_session[self.labels] = feed_dict[\"labels\"]\n feed_dict_for_session[self.weights] = feed_dict[\"weights\"]\n\n pred_probs, loss = self.sess.run(\n [self.predictions, self.cost], feed_dict=feed_dict_for_session\n )\n\n result = {\"loss\": _np.array(loss), \"output\": _np.array(pred_probs)}\n else:\n pred_probs = self.sess.run(\n [self.predictions], feed_dict=feed_dict_for_session\n )\n result = {\"output\": _np.array(pred_probs)}\n\n return result\n\n def export_weights(self):\n \"\"\"\n Retrieve weights from the TF model, convert to the format Core ML\n expects and store in a dictionary.\n\n Returns\n -------\n net_params : dict\n Dictionary of weights, where the key is the name of the\n layer (e.g. `drawing_conv0_weight`) and the value is the\n respective weight of type `numpy.ndarray`.\n \"\"\"\n\n net_params = {}\n with self.dc_graph.as_default():\n layer_names = _tf.trainable_variables()\n layer_weights = self.sess.run(layer_names)\n\n for var, val in zip(layer_names, layer_weights):\n if \"bias\" in var.name:\n net_params.update({var.name.replace(\":0\", \"\"): val})\n else:\n if \"dense\" in var.name:\n if \"drawing_dense0_weight\" in var.name:\n \"\"\"\n To make output of TF pool3 (NHWC) compatible with CoreML (NCHW).\n Decompose FC weights to NHWC. Transpose to NCHW. Reshape back to FC.\n \"\"\"\n tf_576_128 = val\n tf_576_128 = _np.reshape(tf_576_128, (3, 3, 64, 128))\n tf_576_128 = _np.transpose(tf_576_128, (2, 0, 1, 3))\n tf_576_128 = _np.reshape(tf_576_128, (576, 128))\n net_params.update(\n {\n var.name.replace(\":0\", \"\"): _np.transpose(\n tf_576_128, (1, 0)\n )\n }\n )\n else:\n net_params.update(\n {var.name.replace(\":0\", \"\"): val.transpose(1, 0)}\n )\n else:\n # np.transpose won't change the underlying memory layout\n # but in turicreate we will force it.\n net_params.update(\n {\n var.name.replace(\n \":0\", \"\"\n ): _utils.convert_conv2d_tf_to_coreml(val)\n }\n )\n\n return net_params\n" ]	[ [ "tensorflow.compat.v1.nn.max_pool2d", "tensorflow.compat.v1.train.AdamOptimizer", "numpy.reshape", "tensorflow.compat.v1.reshape", "tensorflow.compat.v1.trainable_variables", "tensorflow.compat.v1.one_hot", "tensorflow.compat.v1.nn.softmax", "tensorflow.compat.v1.nn.conv2d", "tensorflow.compat.v1.Graph", "tensorflow.compat.v1.nn.relu", "tensorflow.compat.v1.losses.softmax_cross_entropy", "numpy.transpose", "numpy.array", "tensorflow.compat.v1.Variable", "tensorflow.compat.v1.disable_v2_behavior", "tensorflow.compat.v1.nn.xw_plus_b", "tensorflow.compat.v1.global_variables_initializer", "tensorflow.compat.v1.Session", "tensorflow.compat.v1.placeholder", "tensorflow.compat.v1.nn.bias_add" ] ]
dgbirm/elo_sailor	[ "0978eac23e9334eee8cab3225840f82fbc153194" ]	[ "ISAFlaserResults/code/csvClean.py" ]	[ "#Scrap code for cleaning the CSV files so that we can read them easier\n\nimport csv\nimport sys\nimport pandas as pd\nimport numpy as np\nimport os\nimport re\n\nfrom selenium import webdriver\nfrom time import sleep\nfrom text_unidecode import unidecode\nfrom tabulate import tabulate\n\nsys.path.append('/home/daniel/Desktop/elo_sailor/Glicko2approach')\nfrom SailingGlicko2 import \nfrom Scrape import \n\nos.chdir(\"..\")\n\ndef getHiddenHTML(currentRegatta):\n browser = webdriver.Firefox()\n browser.get(currentRegatta)\n sleep(2)\n innerHTML = browser.execute_script(\"return document.getElementsByTagName('html')[0].innerHTML\")\n browser.close()\n return innerHTML\n\ncolorlst=[('0000ff', '2'), ('0000ff', '21'), ('bbbb00', '4'), ('bbbb00', '4'), ('bbbb00', '3'), ('bbbb00', '4'), ('999900', '8'), ('999900', '2'), ('999900', '5'), ('999900', '13'), ('999900', '14'), ('999900', '51'), ('0000ff', '2'), ('0000ff', '21'), ('bbbb00', '4'), ('bbbb00', '4'), ('bbbb00', '3'), ('bbbb00', '4'), ('999900', '8'), ('999900', '2'), ('999900', '5'), ('999900', '13'), ('999900', '14'), ('999900', '51'), ('ff0000', '13'), ('ff0000', '7'), ('ff0000', '3'), ('ff0000', '1'), ('0000ff', '2'), ('0000ff', '1'), ('999900', '19'), ('999900', '18'), ('999900', '30'), ('999900', '1'), ('999900', '6'), ('999900', '5'), ('ff0000', '13'), ('ff0000', '7'), ('ff0000', '3'), ('ff0000', '1'), ('0000ff', '2'), ('0000ff', '1'), ('999900', '19'), ('999900', '18'), ('999900', '30'), ('999900', '1'), ('999900', '6'), ('999900', '5'), ('ff0000', '2'), ('ff0000', '2'), ('0000ff', '3'), ('0000ff', '7'), ('ff0000', '4'), ('ff0000', '53 UFD'), ('999900', '4'), ('999900', '38'), ('999900', '13'), ('999900', '23'), ('999900', '2'), ('999900', '9'), ('ff0000', '2'), ('ff0000', '2'), ('0000ff', '3'), ('0000ff', '7'), ('ff0000', '4'), ('ff0000', '53 UFD'), ('999900', '4'), ('999900', '38'), ('999900', '13'), ('999900', '23'), ('999900', '2'), ('999900', '9'), ('0000ff', '12'), ('0000ff', '7'), ('bbbb00', '2'), ('bbbb00', '2'), ('ff0000', '1'), ('ff0000', '1'), ('999900', '17'), ('999900', '8'), ('999900', '39'), ('999900', '21'), ('999900', '1'), ('999900', '12'), ('0000ff', '12'), ('0000ff', '7'), ('bbbb00', '2'), ('bbbb00', '2'), ('ff0000', '1'), ('ff0000', '1'), ('999900', '17'), ('999900', '8'), ('999900', '39'), ('999900', '21'), ('999900', '1'), ('999900', '12'), ('ff0000', '17'), ('ff0000', '4'), ('0000ff', '9'), ('0000ff', '9'), ('bbbb00', '2'), ('bbbb00', '5'), ('999900', '23'), ('999900', '7'), ('999900', '7'), ('999900', '22'), ('999900', '4'), ('999900', '4'), ('ff0000', '17'), ('ff0000', '4'), ('0000ff', '9'), ('0000ff', '9'), ('bbbb00', '2'), ('bbbb00', '5'), ('999900', '23'), ('999900', '7'), ('999900', '7'), ('999900', '22'), ('999900', '4'), ('999900', '4'), ('0000ff', '3'), ('0000ff', '2'), ('ff0000', '7'), ('ff0000', '2'), ('0000ff', '1'), ('0000ff', '7'), ('999900', '22'), ('999900', '22'), ('999900', '2'), ('999900', '11'), ('999900', '8'), ('999900', '20'), ('0000ff', '3'), ('0000ff', '2'), ('ff0000', '7'), ('ff0000', '2'), ('0000ff', '1'), ('0000ff', '7'), ('999900', '22'), ('999900', '22'), ('999900', '2'), ('999900', '11'), ('999900', '8'), ('999900', '20'), ('bbbb00', '5'), ('bbbb00', '13'), ('0000ff', '5'), ('0000ff', '4'), ('bbbb00', '1'), ('bbbb00', '1'), ('999900', '24'), ('999900', '40'), ('999900', '29'), ('999900', '4'), ('999900', '9'), ('999900', '10'), ('bbbb00', '5'), ('bbbb00', '13'), ('0000ff', '5'), ('0000ff', '4'), ('bbbb00', '1'), ('bbbb00', '1'), ('999900', '24'), ('999900', '40'), ('999900', '29'), ('999900', '4'), ('999900', '9'), ('999900', '10'), ('ff0000', '5'), ('ff0000', '6'), ('bbbb00', '12'), ('bbbb00', '14'), ('ff0000', '15'), ('ff0000', '7'), ('999900', '16'), ('999900', '6'), ('999900', '12'), ('999900', '7'), ('999900', '45'), ('999900', '7'), ('ff0000', '5'), ('ff0000', '6'), ('bbbb00', '12'), ('bbbb00', '14'), ('ff0000', '15'), ('ff0000', '7'), ('999900', '16'), ('999900', '6'), ('999900', '12'), ('999900', '7'), ('999900', '45'), ('999900', '7'), ('bbbb00', '6'), ('bbbb00', '10'), ('ff0000', '2'), ('ff0000', '5'), ('0000ff', '7'), ('0000ff', '3'), ('999900', '7'), ('999900', '14'), ('999900', '31'), ('999900', '10'), ('999900', '53 BFD'), ('999900', '11'), ('bbbb00', '6'), ('bbbb00', '10'), ('ff0000', '2'), ('ff0000', '5'), ('0000ff', '7'), ('0000ff', '3'), ('999900', '7'), ('999900', '14'), ('999900', '31'), ('999900', '10'), ('999900', '53 BFD'), ('999900', '11'), ('bbbb00', '21'), ('bbbb00', '5'), ('ff0000', '10'), ('ff0000', '7'), ('0000ff', '3'), ('0000ff', '4'), ('999900', '15'), ('999900', '11'), ('999900', '18'), ('999900', '6'), ('999900', '32'), ('999900', '17'), ('bbbb00', '21'), ('bbbb00', '5'), ('ff0000', '10'), ('ff0000', '7'), ('0000ff', '3'), ('0000ff', '4'), ('999900', '15'), ('999900', '11'), ('999900', '18'), ('999900', '6'), ('999900', '32'), ('999900', '17'), ('ff0000', '15'), ('ff0000', '18'), ('ff0000', '6'), ('ff0000', '6'), ('ff0000', '2'), ('ff0000', '4'), ('999900', '35'), ('999900', '15'), ('999900', '3'), ('999900', '2'), ('999900', '18'), ('999900', '34'), ('ff0000', '15'), ('ff0000', '18'), ('ff0000', '6'), ('ff0000', '6'), ('ff0000', '2'), ('ff0000', '4'), ('999900', '35'), ('999900', '15'), ('999900', '3'), ('999900', '2'), ('999900', '18'), ('999900', '34'), ('0000ff', '27'), ('0000ff', '3'), ('0000ff', '4'), ('0000ff', '3'), ('bbbb00', '5'), ('bbbb00', '2'), ('999900', '14'), ('999900', '30'), ('999900', '15'), ('999900', '25'), ('999900', '21'), ('999900', '32'), ('0000ff', '27'), ('0000ff', '3'), ('0000ff', '4'), ('0000ff', '3'), ('bbbb00', '5'), ('bbbb00', '2'), ('999900', '14'), ('999900', '30'), ('999900', '15'), ('999900', '25'), ('999900', '21'), ('999900', '32'), ('ff0000', '8'), ('ff0000', '3'), ('bbbb00', '3'), ('bbbb00', '1'), ('bbbb00', '8'), ('bbbb00', '8'), ('999900', '22 SCP'), ('999900', '27'), ('999900', '28'), ('999900', '12'), ('999900', '33'), ('999900', '13'), ('ff0000', '8'), ('ff0000', '3'), ('bbbb00', '3'), ('bbbb00', '1'), ('bbbb00', '8'), ('bbbb00', '8'), ('999900', '22 SCP'), ('999900', '27'), ('999900', '28'), ('999900', '12'), ('999900', '33'), ('999900', '13'), ('0000ff', '6'), ('0000ff', '17'), ('bbbb00', '15'), ('bbbb00', '15'), ('0000ff', '14'), ('0000ff', '17'), ('999900', '3'), ('999900', '3'), ('999900', '20'), ('999900', '37'), ('999900', '17'), ('999900', '19'), ('0000ff', '6'), ('0000ff', '17'), ('bbbb00', '15'), ('bbbb00', '15'), ('0000ff', '14'), ('0000ff', '17'), ('999900', '3'), ('999900', '3'), ('999900', '20'), ('999900', '37'), ('999900', '17'), ('999900', '19'), ('bbbb00', '4'), ('bbbb00', '4'), ('ff0000', '1'), ('ff0000', '8'), ('0000ff', '13'), ('0000ff', '10'), ('999900', '49'), ('999900', '45'), ('999900', '35'), ('999900', '9'), ('999900', '15'), ('999900', '2'), ('bbbb00', '4'), ('bbbb00', '4'), ('ff0000', '1'), ('ff0000', '8'), ('0000ff', '13'), ('0000ff', '10'), ('999900', '49'), ('999900', '45'), ('999900', '35'), ('999900', '9'), ('999900', '15'), ('999900', '2'), ('0000ff', '16'), ('0000ff', '12'), ('0000ff', '2'), ('0000ff', '1'), ('bbbb00', '4'), ('bbbb00', '3'), ('999900', '27'), ('999900', '21'), ('999900', '33'), ('999900', '29'), ('999900', '29'), ('999900', '6'), ('0000ff', '16'), ('0000ff', '12'), ('0000ff', '2'), ('0000ff', '1'), ('bbbb00', '4'), ('bbbb00', '3'), ('999900', '27'), ('999900', '21'), ('999900', '33'), ('999900', '29'), ('999900', '29'), ('999900', '6'), ('ff0000', '14'), ('ff0000', '1'), ('bbbb00', '8'), ('bbbb00', '3'), ('ff0000', '9'), ('ff0000', '9'), ('999900', '1'), ('999900', '46'), ('999900', '41'), ('999900', '33'), ('999900', '30'), ('999900', '3'), ('ff0000', '14'), ('ff0000', '1'), ('bbbb00', '8'), ('bbbb00', '3'), ('ff0000', '9'), ('ff0000', '9'), ('999900', '1'), ('999900', '46'), ('999900', '41'), ('999900', '33'), ('999900', '30'), ('999900', '3'), ('ff0000', '18'), ('ff0000', '53 BFD'), ('ff0000', '4'), ('ff0000', '9'), ('bbbb00', '6'), ('bbbb00', '7'), ('999900', '53 UFD'), ('999900', '34'), ('999900', '10'), ('999900', '15'), ('999900', '22'), ('999900', '15'), ('ff0000', '18'), ('ff0000', '53 BFD'), ('ff0000', '4'), ('ff0000', '9'), ('bbbb00', '6'), ('bbbb00', '7'), ('999900', '53 UFD'), ('999900', '34'), ('999900', '10'), ('999900', '15'), ('999900', '22'), ('999900', '15'), ('0000ff', '5'), ('0000ff', '20'), ('0000ff', '1'), ('0000ff', '16'), ('bbbb00', '15'), ('bbbb00', '10'), ('999900', '36'), ('999900', '9'), ('999900', '4'), ('999900', '3'), ('999900', '42'), ('999900', '43'), ('0000ff', '5'), ('0000ff', '20'), ('0000ff', '1'), ('0000ff', '16'), ('bbbb00', '15'), ('bbbb00', '10'), ('999900', '36'), ('999900', '9'), ('999900', '4'), ('999900', '3'), ('999900', '42'), ('999900', '43'), ('bbbb00', '9'), ('bbbb00', '2'), ('0000ff', '10'), ('0000ff', '8'), ('ff0000', '23'), ('ff0000', '13'), ('999900', '11'), ('999900', '44'), ('999900', '19'), ('999900', '14'), ('999900', '20'), ('999900', '39'), ('bbbb00', '9'), ('bbbb00', '2'), ('0000ff', '10'), ('0000ff', '8'), ('ff0000', '23'), ('ff0000', '13'), ('999900', '11'), ('999900', '44'), ('999900', '19'), ('999900', '14'), ('999900', '20'), ('999900', '39'), ('bbbb00', '37'), ('bbbb00', '53 BFD'), ('bbbb00', '1'), ('bbbb00', '5'), ('0000ff', '6'), ('0000ff', '5'), ('999900', '26'), ('999900', '26'), ('999900', '32'), ('999900', '20'), ('999900', '12'), ('999900', '16'), ('bbbb00', '37'), ('bbbb00', '53 BFD'), ('bbbb00', '1'), ('bbbb00', '5'), ('0000ff', '6'), ('0000ff', '5'), ('999900', '26'), ('999900', '26'), ('999900', '32'), ('999900', '20'), ('999900', '12'), ('999900', '16'), ('bbbb00', '7'), ('bbbb00', '7'), ('0000ff', '53 BFD'), ('0000ff', '6'), ('0000ff', '11'), ('0000ff', '11'), ('999900', '30'), ('999900', '29'), ('999900', '9'), ('999900', '26'), ('999900', '16'), ('999900', '31'), ('bbbb00', '7'), ('bbbb00', '7'), ('0000ff', '53 BFD'), ('0000ff', '6'), ('0000ff', '11'), ('0000ff', '11'), ('999900', '30'), ('999900', '29'), ('999900', '9'), ('999900', '26'), ('999900', '16'), ('999900', '31'), ('0000ff', '14'), ('0000ff', '16'), ('ff0000', '16'), ('ff0000', '10'), ('0000ff', '15'), ('0000ff', '2'), ('999900', '18'), ('999900', '42'), ('999900', '47'), ('999900', '17'), ('999900', '13'), ('999900', '8'), ('0000ff', '14'), ('0000ff', '16'), ('ff0000', '16'), ('ff0000', '10'), ('0000ff', '15'), ('0000ff', '2'), ('999900', '18'), ('999900', '42'), ('999900', '47'), ('999900', '17'), ('999900', '13'), ('999900', '8'), ('bbbb00', '1'), ('bbbb00', '3'), ('bbbb00', '17'), ('bbbb00', '12'), ('0000ff', '9'), ('0000ff', '6'), ('999900', '9'), ('999900', '37'), ('999900', '8'), ('999900', '34'), ('999900', '49'), ('999900', '40'), ('bbbb00', '1'), ('bbbb00', '3'), ('bbbb00', '17'), ('bbbb00', '12'), ('0000ff', '9'), ('0000ff', '6'), ('999900', '9'), ('999900', '37'), ('999900', '8'), ('999900', '34'), ('999900', '49'), ('999900', '40'), ('0000ff', '30'), ('0000ff', '26'), ('0000ff', '7'), ('0000ff', '15'), ('ff0000', '3'), ('ff0000', '6'), ('999900', '32'), ('999900', '43'), ('999900', '42'), ('999900', '18'), ('999900', '10'), ('999900', '1'), ('0000ff', '30'), ('0000ff', '26'), ('0000ff', '7'), ('0000ff', '15'), ('ff0000', '3'), ('ff0000', '6'), ('999900', '32'), ('999900', '43'), ('999900', '42'), ('999900', '18'), ('999900', '10'), ('999900', '1'), ('ff0000', '20'), ('ff0000', '17'), ('0000ff', '11'), ('0000ff', '19'), ('bbbb00', '17'), ('bbbb00', '11'), ('999900', '10'), ('999900', '23'), ('999900', '22'), ('999900', '31'), ('999900', '3'), ('999900', '33'), ('ff0000', '20'), ('ff0000', '17'), ('0000ff', '11'), ('0000ff', '19'), ('bbbb00', '17'), ('bbbb00', '11'), ('999900', '10'), ('999900', '23'), ('999900', '22'), ('999900', '31'), ('999900', '3'), ('999900', '33'), ('ff0000', '9'), ('ff0000', '25'), ('0000ff', '14'), ('0000ff', '5'), ('0000ff', '21'), ('0000ff', '19'), ('999900', '29'), ('999900', '10'), ('999900', '21'), ('999900', '8'), ('999900', '37'), ('999900', '38'), ('ff0000', '9'), ('ff0000', '25'), ('0000ff', '14'), ('0000ff', '5'), ('0000ff', '21'), ('0000ff', '19'), ('999900', '29'), ('999900', '10'), ('999900', '21'), ('999900', '8'), ('999900', '37'), ('999900', '38'), ('ff0000', '32'), ('ff0000', '16'), ('0000ff', '16'), ('0000ff', '17'), ('0000ff', '5'), ('0000ff', '8'), ('999900', '5'), ('999900', '48'), ('999900', '1'), ('999900', '40'), ('999900', '53 BFD'), ('999900', '18'), ('ff0000', '32'), ('ff0000', '16'), ('0000ff', '16'), ('0000ff', '17'), ('0000ff', '5'), ('0000ff', '8'), ('999900', '5'), ('999900', '48'), ('999900', '1'), ('999900', '40'), ('999900', '53 BFD'), ('999900', '18'), ('0000ff', '8'), ('0000ff', '6'), ('ff0000', '22'), ('ff0000', '14'), ('bbbb00', '12'), ('bbbb00', '21'), ('999900', '37'), ('999900', '33'), ('999900', '14'), ('999900', '5'), ('999900', '27'), ('999900', '47'), ('0000ff', '8'), ('0000ff', '6'), ('ff0000', '22'), ('ff0000', '14'), ('bbbb00', '12'), ('bbbb00', '21'), ('999900', '37'), ('999900', '33'), ('999900', '14'), ('999900', '5'), ('999900', '27'), ('999900', '47'), ('bbbb00', '2'), ('bbbb00', '28'), ('bbbb00', '13'), ('bbbb00', '9'), ('0000ff', '18'), ('0000ff', '18'), ('999900', '34'), ('999900', '13'), ('999900', '50'), ('999900', '32'), ('999900', '34'), ('999900', '14'), ('bbbb00', '2'), ('bbbb00', '28'), ('bbbb00', '13'), ('bbbb00', '9'), ('0000ff', '18'), ('0000ff', '18'), ('999900', '34'), ('999900', '13'), ('999900', '50'), ('999900', '32'), ('999900', '34'), ('999900', '14'), ('ff0000', '35'), ('ff0000', '5'), ('0000ff', '17'), ('0000ff', '11'), ('ff0000', '7'), ('ff0000', '23'), ('999900', '13'), ('999900', '35'), ('999900', '17'), ('999900', '35 SCP'), ('999900', '26'), ('999900', '36'), ('ff0000', '35'), ('ff0000', '5'), ('0000ff', '17'), ('0000ff', '11'), ('ff0000', '7'), ('ff0000', '23'), ('999900', '13'), ('999900', '35'), ('999900', '17'), ('999900', '35 SCP'), ('999900', '26'), ('999900', '36'), ('ff0000', '19'), ('ff0000', '14'), ('ff0000', '13'), ('ff0000', '21'), ('bbbb00', '21'), ('bbbb00', '6'), ('999900', '44'), ('999900', '28'), ('999900', '6'), ('999900', '16'), ('999900', '28'), ('999900', '45'), ('ff0000', '19'), ('ff0000', '14'), ('ff0000', '13'), ('ff0000', '21'), ('bbbb00', '21'), ('bbbb00', '6'), ('999900', '44'), ('999900', '28'), ('999900', '6'), ('999900', '16'), ('999900', '28'), ('999900', '45'), ('ff0000', '23'), ('ff0000', '24'), ('0000ff', '12'), ('0000ff', '12'), ('0000ff', '8'), ('0000ff', '20'), ('999900', '12'), ('999900', '24'), ('999900', '37'), ('999900', '42'), ('999900', '7'), ('999900', '41'), ('ff0000', '23'), ('ff0000', '24'), ('0000ff', '12'), ('0000ff', '12'), ('0000ff', '8'), ('0000ff', '20'), ('999900', '12'), ('999900', '24'), ('999900', '37'), ('999900', '42'), ('999900', '7'), ('999900', '41'), ('ff0000', '26'), ('ff0000', '12'), ('bbbb00', '11'), ('bbbb00', '10'), ('ff0000', '12'), ('ff0000', '8'), ('999900', '21'), ('999900', '21 SCP'), ('999900', '44'), ('999900', '50'), ('999900', '31'), ('999900', '26'), ('ff0000', '26'), ('ff0000', '12'), ('bbbb00', '11'), ('bbbb00', '10'), ('ff0000', '12'), ('ff0000', '8'), ('999900', '21'), ('999900', '21 SCP'), ('999900', '44'), ('999900', '50'), ('999900', '31'), ('999900', '26'), ('0000ff', '4'), ('0000ff', '15'), ('bbbb00', '7'), ('bbbb00', '7'), ('ff0000', '17'), ('ff0000', '3'), ('999900', '2'), ('999900', '52'), ('999900', '34'), ('999900', '48'), ('999900', '40'), ('999900', '37'), ('0000ff', '4'), ('0000ff', '15'), ('bbbb00', '7'), ('bbbb00', '7'), ('ff0000', '17'), ('ff0000', '3'), ('999900', '2'), ('999900', '52'), ('999900', '34'), ('999900', '48'), ('999900', '40'), ('999900', '37'), ('0000ff', '9'), ('0000ff', '22'), ('ff0000', '11'), ('ff0000', '4'), ('bbbb00', '7'), ('bbbb00', '9'), ('999900', '40'), ('999900', '19'), ('999900', '38'), ('999900', '41'), ('999900', '38'), ('999900', '24'), ('0000ff', '9'), ('0000ff', '22'), ('ff0000', '11'), ('ff0000', '4'), ('bbbb00', '7'), ('bbbb00', '9'), ('999900', '40'), ('999900', '19'), ('999900', '38'), ('999900', '41'), ('999900', '38'), ('999900', '24'), ('0000ff', '36'), ('0000ff', '9'), ('0000ff', '13'), ('0000ff', '21'), ('ff0000', '20'), ('ff0000', '5'), ('999900', '39'), ('999900', '32'), ('999900', '16'), ('999900', '35'), ('999900', '11'), ('999900', '50'), ('0000ff', '36'), ('0000ff', '9'), ('0000ff', '13'), ('0000ff', '21'), ('ff0000', '20'), ('ff0000', '5'), ('999900', '39'), ('999900', '32'), ('999900', '16'), ('999900', '35'), ('999900', '11'), ('999900', '50'), ('ff0000', '29'), ('ff0000', '13'), ('0000ff', '53 BFD'), ('0000ff', '10'), ('0000ff', '12'), ('0000ff', '16'), ('999900', '48'), ('999900', '31'), ('999900', '25'), ('999900', '30'), ('999900', '5'), ('999900', '30'), ('ff0000', '29'), ('ff0000', '13'), ('0000ff', '53 BFD'), ('0000ff', '10'), ('0000ff', '12'), ('0000ff', '16'), ('999900', '48'), ('999900', '31'), ('999900', '25'), ('999900', '30'), ('999900', '5'), ('999900', '30'), ('0000ff', '1'), ('0000ff', '19'), ('0000ff', '6'), ('0000ff', '25'), ('0000ff', '20'), ('0000ff', '35'), ('999900', '45'), ('999900', '12'), ('999900', '11'), ('999900', '28'), ('999900', '47'), ('999900', '35'), ('0000ff', '1'), ('0000ff', '19'), ('0000ff', '6'), ('0000ff', '25'), ('0000ff', '20'), ('0000ff', '35'), ('999900', '45'), ('999900', '12'), ('999900', '11'), ('999900', '28'), ('999900', '47'), ('999900', '35'), ('0000ff', '24'), ('0000ff', '30'), ('bbbb00', '10'), ('bbbb00', '11'), ('ff0000', '18'), ('ff0000', '17'), ('999900', '42'), ('999900', '1'), ('999900', '27'), ('999900', '38'), ('999900', '41'), ('999900', '21'), ('0000ff', '24'), ('0000ff', '30'), ('bbbb00', '10'), ('bbbb00', '11'), ('ff0000', '18'), ('ff0000', '17'), ('999900', '42'), ('999900', '1'), ('999900', '27'), ('999900', '38'), ('999900', '41'), ('999900', '21'), ('0000ff', '34'), ('0000ff', '25'), ('0000ff', '8'), ('0000ff', '20'), ('ff0000', '10'), ('ff0000', '11'), ('999900', '28'), ('999900', '20'), ('999900', '43'), ('999900', '44'), ('999900', '24'), ('999900', '28'), ('0000ff', '34'), ('0000ff', '25'), ('0000ff', '8'), ('0000ff', '20'), ('ff0000', '10'), ('ff0000', '11'), ('999900', '28'), ('999900', '20'), ('999900', '43'), ('999900', '44'), ('999900', '24'), ('999900', '28'), ('bbbb00', '13'), ('bbbb00', '1'), ('ff0000', '5'), ('ff0000', '3'), ('ff0000', '8'), ('ff0000', '2'), ('999900', '53 UFD'), ('999900', '36'), ('999900', '23'), ('999900', '52'), ('999900', '44'), ('999900', '44'), ('bbbb00', '13'), ('bbbb00', '1'), ('ff0000', '5'), ('ff0000', '3'), ('ff0000', '8'), ('ff0000', '2'), ('999900', '53 UFD'), ('999900', '36'), ('999900', '23'), ('999900', '52'), ('999900', '44'), ('999900', '44'), ('0000ff', '28'), ('0000ff', '1'), ('bbbb00', '6'), ('bbbb00', '16'), ('ff0000', '29'), ('ff0000', '10'), ('999900', '41'), ('999900', '25'), ('999900', '40'), ('999900', '39'), ('999900', '25'), ('999900', '29'), ('0000ff', '28'), ('0000ff', '1'), ('bbbb00', '6'), ('bbbb00', '16'), ('ff0000', '29'), ('ff0000', '10'), ('999900', '41'), ('999900', '25'), ('999900', '40'), ('999900', '39'), ('999900', '25'), ('999900', '29'), ('bbbb00', '12'), ('bbbb00', '53 BFD'), ('ff0000', '14'), ('ff0000', '19'), ('0000ff', '4'), ('0000ff', '14'), ('999900', '20'), ('999900', '41'), ('999900', '24'), ('999900', '43'), ('999900', '36'), ('999900', '53'), ('bbbb00', '12'), ('bbbb00', '53 BFD'), ('ff0000', '14'), ('ff0000', '19'), ('0000ff', '4'), ('0000ff', '14'), ('999900', '20'), ('999900', '41'), ('999900', '24'), ('999900', '43'), ('999900', '36'), ('999900', '53'), ('ff0000', '1'), ('ff0000', '11'), ('0000ff', '15'), ('0000ff', '24'), ('ff0000', '26'), ('ff0000', '22'), ('999900', '33'), ('999900', '4'), ('999900', '51'), ('999900', '45'), ('999900', '53 BFD'), ('999900', '25'), ('ff0000', '1'), ('ff0000', '11'), ('0000ff', '15'), ('0000ff', '24'), ('ff0000', '26'), ('ff0000', '22'), ('999900', '33'), ('999900', '4'), ('999900', '51'), ('999900', '45'), ('999900', '53 BFD'), ('999900', '25'), ('0000ff', '11'), ('0000ff', '4'), ('bbbb00', '25'), ('bbbb00', '17'), ('0000ff', '25'), ('0000ff', '27'), ('999900', '43'), ('999900', '16'), ('999900', '26'), ('999900', '46'), ('999900', '23'), ('999900', '42'), ('0000ff', '11'), ('0000ff', '4'), ('bbbb00', '25'), ('bbbb00', '17'), ('0000ff', '25'), ('0000ff', '27'), ('999900', '43'), ('999900', '16'), ('999900', '26'), ('999900', '46'), ('999900', '23'), ('999900', '42'), ('bbbb00', '27'), ('bbbb00', '14'), ('ff0000', '9'), ('ff0000', '17'), ('ff0000', '13'), ('ff0000', '15'), ('999900', '25'), ('999900', '51'), ('999900', '48'), ('999900', '27'), ('999900', '48'), ('999900', '27'), ('bbbb00', '27'), ('bbbb00', '14'), ('ff0000', '9'), ('ff0000', '17'), ('ff0000', '13'), ('ff0000', '15'), ('999900', '25'), ('999900', '51'), ('999900', '48'), ('999900', '27'), ('999900', '48'), ('999900', '27'), ('ff0000', '6'), ('ff0000', '9'), ('0000ff', '27'), ('0000ff', '22'), ('bbbb00', '36'), ('bbbb00', '16'), ('999900', '50'), ('999900', '50'), ('999900', '36'), ('999900', '24'), ('999900', '35'), ('999900', '23'), ('ff0000', '6'), ('ff0000', '9'), ('0000ff', '27'), ('0000ff', '22'), ('bbbb00', '36'), ('bbbb00', '16'), ('999900', '50'), ('999900', '50'), ('999900', '36'), ('999900', '24'), ('999900', '35'), ('999900', '23'), ('ff0000', '30'), ('ff0000', '10'), ('bbbb00', '9'), ('bbbb00', '18'), ('bbbb00', '23'), ('bbbb00', '15'), ('999900', '47'), ('999900', '17'), ('999900', '49'), ('999900', '49'), ('999900', '19'), ('999900', '49'), ('ff0000', '30'), ('ff0000', '10'), ('bbbb00', '9'), ('bbbb00', '18'), ('bbbb00', '23'), ('bbbb00', '15'), ('999900', '47'), ('999900', '17'), ('999900', '49'), ('999900', '49'), ('999900', '19'), ('999900', '49'), ('ff0000', '12'), ('ff0000', '28'), ('bbbb00', '5'), ('bbbb00', '8'), ('bbbb00', '25'), ('bbbb00', '12'), ('999900', '38'), ('999900', '39'), ('999900', '45'), ('999900', '36'), ('999900', '43'), ('999900', '46'), ('ff0000', '12'), ('ff0000', '28'), ('bbbb00', '5'), ('bbbb00', '8'), ('bbbb00', '25'), ('bbbb00', '12'), ('999900', '38'), ('999900', '39'), ('999900', '45'), ('999900', '36'), ('999900', '43'), ('999900', '46'), ('ff0000', '3'), ('ff0000', '53 BFD'), ('ff0000', '17'), ('ff0000', '22'), ('bbbb00', '14'), ('bbbb00', '13'), ('999900', '31'), ('999900', '49'), ('999900', '53 UFD'), ('999900', '51'), ('999900', '46'), ('999900', '22'), ('ff0000', '3'), ('ff0000', '53 BFD'), ('ff0000', '17'), ('ff0000', '22'), ('bbbb00', '14'), ('bbbb00', '13'), ('999900', '31'), ('999900', '49'), ('999900', '53 UFD'), ('999900', '51'), ('999900', '46'), ('999900', '22'), ('bbbb00', '20'), ('bbbb00', '12'), ('bbbb00', '20'), ('bbbb00', '6'), ('0000ff', '27'), ('0000ff', '9'), ('999900', '46'), ('999900', '47'), ('999900', '46'), ('999900', '47'), ('999900', '39'), ('999900', '48'), ('bbbb00', '20'), ('bbbb00', '12'), ('bbbb00', '20'), ('bbbb00', '6'), ('0000ff', '27'), ('0000ff', '9'), ('999900', '46'), ('999900', '47'), ('999900', '46'), ('999900', '47'), ('999900', '39'), ('999900', '48'), ('0000ff', '19'), ('0000ff', '8'), ('ff0000', '27'), ('ff0000', '15'), ('bbbb00', '30'), ('bbbb00', '18'), ('999999', '1'), ('999999', '2'), ('999999', '15'), ('999999', '6'), ('999999', '15'), ('999999', '13'), ('0000ff', '19'), ('0000ff', '8'), ('ff0000', '27'), ('ff0000', '15'), ('bbbb00', '30'), ('bbbb00', '18'), ('999999', '1'), ('999999', '2'), ('999999', '15'), ('999999', '6'), ('999999', '15'), ('999999', '13'), ('bbbb00', '14'), ('bbbb00', '24'), ('0000ff', '23'), ('0000ff', '35'), ('bbbb00', '11'), ('bbbb00', '30'), ('999999', '3'), ('999999', '3'), ('999999', '13'), ('999999', '1'), ('999999', '7'), ('999999', '16'), ('bbbb00', '14'), ('bbbb00', '24'), ('0000ff', '23'), ('0000ff', '35'), ('bbbb00', '11'), ('bbbb00', '30'), ('999999', '3'), ('999999', '3'), ('999999', '13'), ('999999', '1'), ('999999', '7'), ('999999', '16'), ('bbbb00', '17'), ('bbbb00', '53 BFD'), ('bbbb00', '24'), ('bbbb00', '30'), ('0000ff', '19'), ('0000ff', '22'), ('999999', '25'), ('999999', '7'), ('999999', '6'), ('999999', '8'), ('999999', '9'), ('999999', '17'), ('bbbb00', '17'), ('bbbb00', '53 BFD'), ('bbbb00', '24'), ('bbbb00', '30'), ('0000ff', '19'), ('0000ff', '22'), ('999999', '25'), ('999999', '7'), ('999999', '6'), ('999999', '8'), ('999999', '9'), ('999999', '17'), ('0000ff', '44'), ('0000ff', '18'), ('ff0000', '12'), ('ff0000', '53 UFD'), ('ff0000', '6'), ('ff0000', '30'), ('999999', '19'), ('999999', '19'), ('999999', '2'), ('999999', '7'), ('999999', '5'), ('999999', '44'), ('0000ff', '44'), ('0000ff', '18'), ('ff0000', '12'), ('ff0000', '53 UFD'), ('ff0000', '6'), ('ff0000', '30'), ('999999', '19'), ('999999', '19'), ('999999', '2'), ('999999', '7'), ('999999', '5'), ('999999', '44'), ('ff0000', '46'), ('ff0000', '8'), ('ff0000', '32'), ('ff0000', '11'), ('bbbb00', '9'), ('bbbb00', '24'), ('999999', '13'), ('999999', '28'), ('999999', '37'), ('999999', '24'), ('999999', '13'), ('999999', '1'), ('ff0000', '46'), ('ff0000', '8'), ('ff0000', '32'), ('ff0000', '11'), ('bbbb00', '9'), ('bbbb00', '24'), ('999999', '13'), ('999999', '28'), ('999999', '37'), ('999999', '24'), ('999999', '13'), ('999999', '1'), ('ff0000', '7'), ('ff0000', '27'), ('bbbb00', '21'), ('bbbb00', '22'), ('bbbb00', '10'), ('bbbb00', '29'), ('999999', '53 BFD'), ('999999', '33'), ('999999', '1'), ('999999', '37'), ('999999', '11'), ('999999', '3'), ('ff0000', '7'), ('ff0000', '27'), ('bbbb00', '21'), ('bbbb00', '22'), ('bbbb00', '10'), ('bbbb00', '29'), ('999999', '53 BFD'), ('999999', '33'), ('999999', '1'), ('999999', '37'), ('999999', '11'), ('999999', '3'), ('bbbb00', '8'), ('bbbb00', '29'), ('ff0000', '19'), ('ff0000', '32'), ('ff0000', '28'), ('ff0000', '21'), ('999999', '21'), ('999999', '6'), ('999999', '30'), ('999999', '9'), ('999999', '12'), ('999999', '20'), ('bbbb00', '8'), ('bbbb00', '29'), ('ff0000', '19'), ('ff0000', '32'), ('ff0000', '28'), ('ff0000', '21'), ('999999', '21'), ('999999', '6'), ('999999', '30'), ('999999', '9'), ('999999', '12'), ('999999', '20'), ('0000ff', '40'), ('0000ff', '34'), ('0000ff', '53 BFD'), ('0000ff', '2'), ('bbbb00', '18'), ('bbbb00', '32'), ('999999', '6'), ('999999', '30'), ('999999', '7'), ('999999', '14'), ('999999', '20'), ('999999', '11'), ('0000ff', '40'), ('0000ff', '34'), ('0000ff', '53 BFD'), ('0000ff', '2'), ('bbbb00', '18'), ('bbbb00', '32'), ('999999', '6'), ('999999', '30'), ('999999', '7'), ('999999', '14'), ('999999', '20'), ('999999', '11'), ('0000ff', '43'), ('0000ff', '13'), ('ff0000', '21'), ('ff0000', '23'), ('bbbb00', '22'), ('bbbb00', '25'), ('999999', '9'), ('999999', '22'), ('999999', '12'), ('999999', '16'), ('999999', '17'), ('999999', '21'), ('0000ff', '43'), ('0000ff', '13'), ('ff0000', '21'), ('ff0000', '23'), ('bbbb00', '22'), ('bbbb00', '25'), ('999999', '9'), ('999999', '22'), ('999999', '12'), ('999999', '16'), ('999999', '17'), ('999999', '21'), ('0000ff', '7'), ('0000ff', '32'), ('ff0000', '30'), ('ff0000', '18'), ('bbbb00', '13'), ('bbbb00', '33'), ('999999', '16'), ('999999', '10'), ('999999', '5'), ('999999', '42'), ('999999', '53 BFD'), ('999999', '8'), ('0000ff', '7'), ('0000ff', '32'), ('ff0000', '30'), ('ff0000', '18'), ('bbbb00', '13'), ('bbbb00', '33'), ('999999', '16'), ('999999', '10'), ('999999', '5'), ('999999', '42'), ('999999', '53 BFD'), ('999999', '8'), ('bbbb00', '29'), ('bbbb00', '31'), ('0000ff', '31'), ('0000ff', '29'), ('ff0000', '24'), ('ff0000', '19'), ('999999', '36'), ('999999', '4'), ('999999', '25'), ('999999', '29'), ('999999', '1'), ('999999', '4'), ('bbbb00', '29'), ('bbbb00', '31'), ('0000ff', '31'), ('0000ff', '29'), ('ff0000', '24'), ('ff0000', '19'), ('999999', '36'), ('999999', '4'), ('999999', '25'), ('999999', '29'), ('999999', '1'), ('999999', '4'), ('bbbb00', '28'), ('bbbb00', '53 BFD'), ('ff0000', '8'), ('ff0000', '27'), ('ff0000', '19'), ('ff0000', '31'), ('999999', '18'), ('999999', '24'), ('999999', '33'), ('999999', '26'), ('999999', '2'), ('999999', '15'), ('bbbb00', '28'), ('bbbb00', '53 BFD'), ('ff0000', '8'), ('ff0000', '27'), ('ff0000', '19'), ('ff0000', '31'), ('999999', '18'), ('999999', '24'), ('999999', '33'), ('999999', '26'), ('999999', '2'), ('999999', '15'), ('ff0000', '40'), ('ff0000', '19'), ('ff0000', '20'), ('ff0000', '29'), ('0000ff', '35'), ('0000ff', '42'), ('999999', '20'), ('999999', '13'), ('999999', '10'), ('999999', '22'), ('999999', '4'), ('999999', '26'), ('ff0000', '40'), ('ff0000', '19'), ('ff0000', '20'), ('ff0000', '29'), ('0000ff', '35'), ('0000ff', '42'), ('999999', '20'), ('999999', '13'), ('999999', '10'), ('999999', '22'), ('999999', '4'), ('999999', '26'), ('ff0000', '10'), ('ff0000', '23'), ('0000ff', '22'), ('0000ff', '34'), ('bbbb00', '37'), ('bbbb00', '17'), ('999999', '14'), ('999999', '17'), ('999999', '18'), ('999999', '15'), ('999999', '32'), ('999999', '30'), ('ff0000', '10'), ('ff0000', '23'), ('0000ff', '22'), ('0000ff', '34'), ('bbbb00', '37'), ('bbbb00', '17'), ('999999', '14'), ('999999', '17'), ('999999', '18'), ('999999', '15'), ('999999', '32'), ('999999', '30'), ('0000ff', '37'), ('0000ff', '11'), ('bbbb00', '26'), ('bbbb00', '29'), ('ff0000', '36'), ('ff0000', '27'), ('999999', '44'), ('999999', '18'), ('999999', '3'), ('999999', '19'), ('999999', '3'), ('999999', '27'), ('0000ff', '37'), ('0000ff', '11'), ('bbbb00', '26'), ('bbbb00', '29'), ('ff0000', '36'), ('ff0000', '27'), ('999999', '44'), ('999999', '18'), ('999999', '3'), ('999999', '19'), ('999999', '3'), ('999999', '27'), ('ff0000', '24'), ('ff0000', '15'), ('ff0000', '26'), ('ff0000', '34'), ('bbbb00', '19'), ('bbbb00', '31'), ('999999', '22'), ('999999', '39'), ('999999', '35'), ('999999', '2'), ('999999', '14'), ('999999', '12'), ('ff0000', '24'), ('ff0000', '15'), ('ff0000', '26'), ('ff0000', '34'), ('bbbb00', '19'), ('bbbb00', '31'), ('999999', '22'), ('999999', '39'), ('999999', '35'), ('999999', '2'), ('999999', '14'), ('999999', '12'), ('0000ff', '32'), ('0000ff', '31'), ('0000ff', '53 BFD'), ('0000ff', '23'), ('0000ff', '17'), ('0000ff', '21'), ('999999', '31'), ('999999', '8'), ('999999', '4'), ('999999', '27'), ('999999', '22'), ('999999', '18'), ('0000ff', '32'), ('0000ff', '31'), ('0000ff', '53 BFD'), ('0000ff', '23'), ('0000ff', '17'), ('0000ff', '21'), ('999999', '31'), ('999999', '8'), ('999999', '4'), ('999999', '27'), ('999999', '22'), ('999999', '18'), ('bbbb00', '11'), ('bbbb00', '6'), ('ff0000', '23'), ('ff0000', '33'), ('ff0000', '25'), ('ff0000', '20'), ('999999', '2'), ('999999', '43'), ('999999', '34'), ('999999', '36'), ('999999', '8'), ('999999', '40'), ('bbbb00', '11'), ('bbbb00', '6'), ('ff0000', '23'), ('ff0000', '33'), ('ff0000', '25'), ('ff0000', '20'), ('999999', '2'), ('999999', '43'), ('999999', '34'), ('999999', '36'), ('999999', '8'), ('999999', '40'), ('bbbb00', '24'), ('bbbb00', '32'), ('bbbb00', '27'), ('bbbb00', '19'), ('0000ff', '26'), ('0000ff', '30'), ('999999', '29'), ('999999', '15'), ('999999', '19'), ('999999', '12'), ('999999', '33'), ('999999', '5'), ('bbbb00', '24'), ('bbbb00', '32'), ('bbbb00', '27'), ('bbbb00', '19'), ('0000ff', '26'), ('0000ff', '30'), ('999999', '29'), ('999999', '15'), ('999999', '19'), ('999999', '12'), ('999999', '33'), ('999999', '5'), ('0000ff', '29'), ('0000ff', '5'), ('bbbb00', '32'), ('bbbb00', '34'), ('0000ff', '44'), ('0000ff', '32'), ('999999', '5'), ('999999', '1'), ('999999', '11'), ('999999', '32'), ('999999', '26'), ('999999', '38'), ('0000ff', '29'), ('0000ff', '5'), ('bbbb00', '32'), ('bbbb00', '34'), ('0000ff', '44'), ('0000ff', '32'), ('999999', '5'), ('999999', '1'), ('999999', '11'), ('999999', '32'), ('999999', '26'), ('999999', '38'), ('0000ff', '25'), ('0000ff', '38'), ('bbbb00', '28'), ('bbbb00', '24'), ('0000ff', '31'), ('0000ff', '28'), ('999999', '15'), ('999999', '20'), ('999999', '21'), ('999999', '39'), ('999999', '6'), ('999999', '10'), ('0000ff', '25'), ('0000ff', '38'), ('bbbb00', '28'), ('bbbb00', '24'), ('0000ff', '31'), ('0000ff', '28'), ('999999', '15'), ('999999', '20'), ('999999', '21'), ('999999', '39'), ('999999', '6'), ('999999', '10'), ('0000ff', '22'), ('0000ff', '28'), ('bbbb00', '14'), ('bbbb00', '20'), ('ff0000', '11'), ('ff0000', '16'), ('999999', '10'), ('999999', '27'), ('999999', '26'), ('999999', '44'), ('999999', '53 BFD'), ('999999', '19'), ('0000ff', '22'), ('0000ff', '28'), ('bbbb00', '14'), ('bbbb00', '20'), ('ff0000', '11'), ('ff0000', '16'), ('999999', '10'), ('999999', '27'), ('999999', '26'), ('999999', '44'), ('999999', '53 BFD'), ('999999', '19'), ('bbbb00', '34'), ('bbbb00', '20'), ('0000ff', '24'), ('0000ff', '26'), ('ff0000', '27'), ('ff0000', '26'), ('999999', '38'), ('999999', '5'), ('999999', '14'), ('999999', '13'), ('999999', '21'), ('999999', '34'), ('bbbb00', '34'), ('bbbb00', '20'), ('0000ff', '24'), ('0000ff', '26'), ('ff0000', '27'), ('ff0000', '26'), ('999999', '38'), ('999999', '5'), ('999999', '14'), ('999999', '13'), ('999999', '21'), ('999999', '34'), ('ff0000', '36'), ('ff0000', '21'), ('ff0000', '15'), ('ff0000', '13'), ('ff0000', '5'), ('ff0000', '28'), ('999999', '4'), ('999999', '40'), ('999999', '48'), ('999999', '5'), ('999999', '53 RET'), ('999999', '32'), ('ff0000', '36'), ('ff0000', '21'), ('ff0000', '15'), ('ff0000', '13'), ('ff0000', '5'), ('ff0000', '28'), ('999999', '4'), ('999999', '40'), ('999999', '48'), ('999999', '5'), ('999999', '53 RET'), ('999999', '32'), ('ff0000', '11'), ('ff0000', '26'), ('ff0000', '46'), ('ff0000', '16'), ('ff0000', '35'), ('ff0000', '53 UFD'), ('999999', '12'), ('999999', '46'), ('999999', '31'), ('999999', '18'), ('999999', '16'), ('999999', '2'), ('ff0000', '11'), ('ff0000', '26'), ('ff0000', '46'), ('ff0000', '16'), ('ff0000', '35'), ('ff0000', '53 UFD'), ('999999', '12'), ('999999', '46'), ('999999', '31'), ('999999', '18'), ('999999', '16'), ('999999', '2'), ('bbbb00', '41'), ('bbbb00', '8'), ('ff0000', '31'), ('ff0000', '38.6 DPI'), ('0000ff', '24'), ('0000ff', '12'), ('999999', '17'), ('999999', '16'), ('999999', '17'), ('999999', '28'), ('999999', '53 RET'), ('999999', '22'), ('bbbb00', '41'), ('bbbb00', '8'), ('ff0000', '31'), ('ff0000', '38.6 DPI'), ('0000ff', '24'), ('0000ff', '12'), ('999999', '17'), ('999999', '16'), ('999999', '17'), ('999999', '28'), ('999999', '53 RET'), ('999999', '22'), ('ff0000', '31'), ('ff0000', '29'), ('bbbb00', '18'), ('bbbb00', '21'), ('ff0000', '31'), ('ff0000', '25'), ('999999', '27'), ('999999', '25'), ('999999', '16'), ('999999', '33'), ('999999', '23'), ('999999', '7'), ('ff0000', '31'), ('ff0000', '29'), ('bbbb00', '18'), ('bbbb00', '21'), ('ff0000', '31'), ('ff0000', '25'), ('999999', '27'), ('999999', '25'), ('999999', '16'), ('999999', '33'), ('999999', '23'), ('999999', '7'), ('0000ff', '41'), ('0000ff', '43'), ('0000ff', '19'), ('0000ff', '13'), ('ff0000', '14'), ('ff0000', '14'), ('999999', '39'), ('999999', '14'), ('999999', '9'), ('999999', '50'), ('999999', '28'), ('999999', '33'), ('0000ff', '41'), ('0000ff', '43'), ('0000ff', '19'), ('0000ff', '13'), ('ff0000', '14'), ('ff0000', '14'), ('999999', '39'), ('999999', '14'), ('999999', '9'), ('999999', '50'), ('999999', '28'), ('999999', '33'), ('0000ff', '20'), ('0000ff', '35'), ('bbbb00', '16'), ('bbbb00', '25'), ('0000ff', '22'), ('0000ff', '29'), ('999999', '11'), ('999999', '12'), ('999999', '38'), ('999999', '17'), ('999999', '53 BFD'), ('999999', '35'), ('0000ff', '20'), ('0000ff', '35'), ('bbbb00', '16'), ('bbbb00', '25'), ('0000ff', '22'), ('0000ff', '29'), ('999999', '11'), ('999999', '12'), ('999999', '38'), ('999999', '17'), ('999999', '53 BFD'), ('999999', '35'), ('0000ff', '26'), ('0000ff', '29'), ('0000ff', '53 BFD'), ('0000ff', '14'), ('bbbb00', '24'), ('bbbb00', '20'), ('999999', '33'), ('999999', '35'), ('999999', '8'), ('999999', '35'), ('999999', '19'), ('999999', '24'), ('0000ff', '26'), ('0000ff', '29'), ('0000ff', '53 BFD'), ('0000ff', '14'), ('bbbb00', '24'), ('bbbb00', '20'), ('999999', '33'), ('999999', '35'), ('999999', '8'), ('999999', '35'), ('999999', '19'), ('999999', '24'), ('0000ff', '38'), ('0000ff', '27'), ('ff0000', '18'), ('ff0000', '26'), ('bbbb00', '32'), ('bbbb00', '22'), ('999999', '32'), ('999999', '21'), ('999999', '24'), ('999999', '23'), ('999999', '10'), ('999999', '39'), ('0000ff', '38'), ('0000ff', '27'), ('ff0000', '18'), ('ff0000', '26'), ('bbbb00', '32'), ('bbbb00', '22'), ('999999', '32'), ('999999', '21'), ('999999', '24'), ('999999', '23'), ('999999', '10'), ('999999', '39'), ('0000ff', '33'), ('0000ff', '23'), ('bbbb00', '29'), ('bbbb00', '38'), ('bbbb00', '28'), ('bbbb00', '26'), ('999999', '28'), ('999999', '26'), ('999999', '29'), ('999999', '4'), ('999999', '25'), ('999999', '31'), ('0000ff', '33'), ('0000ff', '23'), ('bbbb00', '29'), ('bbbb00', '38'), ('bbbb00', '28'), ('bbbb00', '26'), ('999999', '28'), ('999999', '26'), ('999999', '29'), ('999999', '4'), ('999999', '25'), ('999999', '31'), ('bbbb00', '23'), ('bbbb00', '21'), ('bbbb00', '19'), ('bbbb00', '28'), ('bbbb00', '26'), ('bbbb00', '14'), ('999999', '53 BFD'), ('999999', '53 BFD'), ('999999', '23'), ('999999', '11'), ('999999', '18'), ('999999', '43'), ('bbbb00', '23'), ('bbbb00', '21'), ('bbbb00', '19'), ('bbbb00', '28'), ('bbbb00', '26'), ('bbbb00', '14'), ('999999', '53 BFD'), ('999999', '53 BFD'), ('999999', '23'), ('999999', '11'), ('999999', '18'), ('999999', '43'), ('bbbb00', '16'), ('bbbb00', '53 BFD'), ('ff0000', '25'), ('ff0000', '40'), ('ff0000', '21'), ('ff0000', '24'), ('999999', '8'), ('999999', '37'), ('999999', '46'), ('999999', '34'), ('999999', '53 BFD'), ('999999', '6'), ('bbbb00', '16'), ('bbbb00', '53 BFD'), ('ff0000', '25'), ('ff0000', '40'), ('ff0000', '21'), ('ff0000', '24'), ('999999', '8'), ('999999', '37'), ('999999', '46'), ('999999', '34'), ('999999', '53 BFD'), ('999999', '6'), ('ff0000', '27'), ('ff0000', '20'), ('ff0000', '33'), ('ff0000', '24'), ('bbbb00', '16'), ('bbbb00', '23'), ('999999', '26'), ('999999', '32'), ('999999', '41'), ('999999', '46'), ('999999', '30'), ('999999', '29'), ('ff0000', '27'), ('ff0000', '20'), ('ff0000', '33'), ('ff0000', '24'), ('bbbb00', '16'), ('bbbb00', '23'), ('999999', '26'), ('999999', '32'), ('999999', '41'), ('999999', '46'), ('999999', '30'), ('999999', '29'), ('bbbb00', '3'), ('bbbb00', '18'), ('ff0000', '43'), ('ff0000', '37.6 DPI'), ('0000ff', '40'), ('0000ff', '31'), ('999999', '37'), ('999999', '11'), ('999999', '28'), ('999999', '41'), ('999999', '29'), ('999999', '36'), ('bbbb00', '3'), ('bbbb00', '18'), ('ff0000', '43'), ('ff0000', '37.6 DPI'), ('0000ff', '40'), ('0000ff', '31'), ('999999', '37'), ('999999', '11'), ('999999', '28'), ('999999', '41'), ('999999', '29'), ('999999', '36'), ('0000ff', '18'), ('0000ff', '14'), ('bbbb00', '30'), ('bbbb00', '32'), ('ff0000', '40'), ('ff0000', '38'), ('999999', '7'), ('999999', '34'), ('999999', '22'), ('999999', '40'), ('999999', '37'), ('999999', '50'), ('0000ff', '18'), ('0000ff', '14'), ('bbbb00', '30'), ('bbbb00', '32'), ('ff0000', '40'), ('ff0000', '38'), ('999999', '7'), ('999999', '34'), ('999999', '22'), ('999999', '40'), ('999999', '37'), ('999999', '50'), ('ff0000', '47'), ('ff0000', '53 BFD'), ('ff0000', '28'), ('ff0000', '28'), ('0000ff', '29'), ('0000ff', '13'), ('999999', '24'), ('999999', '41'), ('999999', '47'), ('999999', '30'), ('999999', '40'), ('999999', '9'), ('ff0000', '47'), ('ff0000', '53 BFD'), ('ff0000', '28'), ('ff0000', '28'), ('0000ff', '29'), ('0000ff', '13'), ('999999', '24'), ('999999', '41'), ('999999', '47'), ('999999', '30'), ('999999', '40'), ('999999', '9'), ('bbbb00', '35'), ('bbbb00', '15'), ('0000ff', '20'), ('0000ff', '18'), ('0000ff', '36'), ('0000ff', '25'), ('999999', '53 RET'), ('999999', '45'), ('999999', '42'), ('999999', '3'), ('999999', '53 BFD'), ('999999', '41'), ('bbbb00', '35'), ('bbbb00', '15'), ('0000ff', '20'), ('0000ff', '18'), ('0000ff', '36'), ('0000ff', '25'), ('999999', '53 RET'), ('999999', '45'), ('999999', '42'), ('999999', '3'), ('999999', '53 BFD'), ('999999', '41'), ('ff0000', '51'), ('ff0000', '22'), ('0000ff', '25'), ('0000ff', '30'), ('ff0000', '16'), ('ff0000', '12'), ('999999', '43'), ('999999', '44'), ('999999', '32'), ('999999', '43'), ('999999', '36'), ('999999', '46'), ('ff0000', '51'), ('ff0000', '22'), ('0000ff', '25'), ('0000ff', '30'), ('ff0000', '16'), ('ff0000', '12'), ('999999', '43'), ('999999', '44'), ('999999', '32'), ('999999', '43'), ('999999', '36'), ('999999', '46'), ('bbbb00', '45'), ('bbbb00', '23'), ('ff0000', '24'), ('ff0000', '30'), ('ff0000', '30'), ('ff0000', '18'), ('999999', '41'), ('999999', '38'), ('999999', '39'), ('999999', '47'), ('999999', '53 BFD'), ('999999', '14'), ('bbbb00', '45'), ('bbbb00', '23'), ('ff0000', '24'), ('ff0000', '30'), ('ff0000', '30'), ('ff0000', '18'), ('999999', '41'), ('999999', '38'), ('999999', '39'), ('999999', '47'), ('999999', '53 BFD'), ('999999', '14'), ('0000ff', '15'), ('0000ff', '53 BFD'), ('0000ff', '35'), ('0000ff', '27'), ('0000ff', '34'), ('0000ff', '37'), ('999999', '23'), ('999999', '53 BFD'), ('999999', '27'), ('999999', '31'), ('999999', '53 BFD'), ('999999', '25'), ('0000ff', '15'), ('0000ff', '53 BFD'), ('0000ff', '35'), ('0000ff', '27'), ('0000ff', '34'), ('0000ff', '37'), ('999999', '23'), ('999999', '53 BFD'), ('999999', '27'), ('999999', '31'), ('999999', '53 BFD'), ('999999', '25'), ('0000ff', '21'), ('0000ff', '10'), ('0000ff', '26'), ('0000ff', '28'), ('0000ff', '38'), ('0000ff', '40'), ('999999', '34'), ('999999', '53 BFD'), ('999999', '49'), ('999999', '25'), ('999999', '35'), ('999999', '49'), ('0000ff', '21'), ('0000ff', '10'), ('0000ff', '26'), ('0000ff', '28'), ('0000ff', '38'), ('0000ff', '40'), ('999999', '34'), ('999999', '53 BFD'), ('999999', '49'), ('999999', '25'), ('999999', '35'), ('999999', '49'), ('0000ff', '23'), ('0000ff', '24'), ('bbbb00', '23'), ('bbbb00', '39'), ('ff0000', '37'), ('ff0000', '40'), ('999999', '40'), ('999999', '53 BFD'), ('999999', '36'), ('999999', '21'), ('999999', '24'), ('999999', '48'), ('0000ff', '23'), ('0000ff', '24'), ('bbbb00', '23'), ('bbbb00', '39'), ('ff0000', '37'), ('ff0000', '40'), ('999999', '40'), ('999999', '53 BFD'), ('999999', '36'), ('999999', '21'), ('999999', '24'), ('999999', '48'), ('bbbb00', '19'), ('bbbb00', '25'), ('bbbb00', '36'), ('bbbb00', '37'), ('0000ff', '30'), ('0000ff', '44'), ('999999', '30'), ('999999', '31'), ('999999', '40'), ('999999', '45'), ('999999', '31'), ('999999', '37'), ('bbbb00', '19'), ('bbbb00', '25'), ('bbbb00', '36'), ('bbbb00', '37'), ('0000ff', '30'), ('0000ff', '44'), ('999999', '30'), ('999999', '31'), ('999999', '40'), ('999999', '45'), ('999999', '31'), ('999999', '37'), ('bbbb00', '30'), ('bbbb00', '11'), ('0000ff', '53 BFD'), ('0000ff', '36'), ('bbbb00', '31'), ('bbbb00', '39'), ('999999', '53 BFD'), ('999999', '29'), ('999999', '53 RET'), ('999999', '20'), ('999999', '27'), ('999999', '42'), ('bbbb00', '30'), ('bbbb00', '11'), ('0000ff', '53 BFD'), ('0000ff', '36'), ('bbbb00', '31'), ('bbbb00', '39'), ('999999', '53 BFD'), ('999999', '29'), ('999999', '53 RET'), ('999999', '20'), ('999999', '27'), ('999999', '42'), ('ff0000', '21'), ('ff0000', '53 BFD'), ('bbbb00', '35'), ('bbbb00', '23'), ('bbbb00', '42'), ('bbbb00', '27'), ('999999', '42'), ('999999', '36'), ('999999', '45'), ('999999', '10'), ('999999', '39'), ('999999', '47'), ('ff0000', '21'), ('ff0000', '53 BFD'), ('bbbb00', '35'), ('bbbb00', '23'), ('bbbb00', '42'), ('bbbb00', '27'), ('999999', '42'), ('999999', '36'), ('999999', '45'), ('999999', '10'), ('999999', '39'), ('999999', '47'), ('bbbb00', '18'), ('bbbb00', '19'), ('bbbb00', '34'), ('bbbb00', '33'), ('bbbb00', '29'), ('bbbb00', '37'), ('999999', '53 RET'), ('999999', '53 BFD'), ('999999', '20'), ('999999', '49'), ('999999', '38'), ('999999', '28'), ('bbbb00', '18'), ('bbbb00', '19'), ('bbbb00', '34'), ('bbbb00', '33'), ('bbbb00', '29'), ('bbbb00', '37'), ('999999', '53 RET'), ('999999', '53 BFD'), ('999999', '20'), ('999999', '49'), ('999999', '38'), ('999999', '28'), ('bbbb00', '48'), ('bbbb00', '37'), ('ff0000', '40'), ('ff0000', '12'), ('bbbb00', '20'), ('bbbb00', '35'), ('999999', '53 BFD'), ('999999', '23'), ('999999', '43'), ('999999', '48'), ('999999', '53 BFD'), ('999999', '23'), ('bbbb00', '48'), ('bbbb00', '37'), ('ff0000', '40'), ('ff0000', '12'), ('bbbb00', '20'), ('bbbb00', '35'), ('999999', '53 BFD'), ('999999', '23'), ('999999', '43'), ('999999', '48'), ('999999', '53 BFD'), ('999999', '23'), ('bbbb00', '26'), ('bbbb00', '27'), ('ff0000', '38'), ('ff0000', '42'), ('bbbb00', '27'), ('bbbb00', '28'), ('999999', '53 BFD'), ('999999', '9'), ('999999', '44'), ('999999', '51'), ('999999', '34'), ('999999', '51'), ('bbbb00', '26'), ('bbbb00', '27'), ('ff0000', '38'), ('ff0000', '42'), ('bbbb00', '27'), ('bbbb00', '28'), ('999999', '53 BFD'), ('999999', '9'), ('999999', '44'), ('999999', '51'), ('999999', '34'), ('999999', '51'), ('0000ff', '17'), ('0000ff', '33'), ('bbbb00', '41'), ('bbbb00', '13'), ('0000ff', '10'), ('0000ff', '15'), ('999999', '53 DNC'), ('999999', '53 DNC'), ('999999', '53 DNC'), ('999999', '53 DNC'), ('999999', '53 DNC'), ('999999', '53'), ('0000ff', '17'), ('0000ff', '33'), ('bbbb00', '41'), ('bbbb00', '13'), ('0000ff', '10'), ('0000ff', '15'), ('999999', '53 DNC'), ('999999', '53 DNC'), ('999999', '53 DNC'), ('999999', '53 DNC'), ('999999', '53 DNC'), ('999999', '53'), ('bbbb00', '31'), ('bbbb00', '35'), ('bbbb00', '33'), ('bbbb00', '26'), ('0000ff', '28'), ('0000ff', '23'), ('999999', '35'), ('999999', '42'), ('999999', '53 UFD'), ('999999', '38'), ('999999', '53 RET'), ('999999', '45'), ('bbbb00', '31'), ('bbbb00', '35'), ('bbbb00', '33'), ('bbbb00', '26'), ('0000ff', '28'), ('0000ff', '23'), ('999999', '35'), ('999999', '42'), ('999999', '53 UFD'), ('999999', '38'), ('999999', '53 RET'), ('999999', '45'), ('ff0000', '33'), ('ff0000', '53 BFD'), ('bbbb00', '22'), ('bbbb00', '31'), ('ff0000', '34'), ('ff0000', '29'), ('8b4513', '9'), ('8b4513', '21'), ('8b4513', '3'), ('8b4513', '9'), ('8b4513', '1'), ('8b4513', '2'), ('ff0000', '33'), ('ff0000', '53 BFD'), ('bbbb00', '22'), ('bbbb00', '31'), ('ff0000', '34'), ('ff0000', '29'), ('8b4513', '9'), ('8b4513', '21'), ('8b4513', '3'), ('8b4513', '9'), ('8b4513', '1'), ('8b4513', '2'), ('bbbb00', '38'), ('bbbb00', '9'), ('ff0000', '42'), ('ff0000', '37'), ('bbbb00', '38'), ('bbbb00', '41'), ('8b4513', '7'), ('8b4513', '28'), ('8b4513', '1'), ('8b4513', '3'), ('8b4513', '2'), ('8b4513', '8'), ('bbbb00', '38'), ('bbbb00', '9'), ('ff0000', '42'), ('ff0000', '37'), ('bbbb00', '38'), ('bbbb00', '41'), ('8b4513', '7'), ('8b4513', '28'), ('8b4513', '1'), ('8b4513', '3'), ('8b4513', '2'), ('8b4513', '8'), ('ff0000', '16'), ('ff0000', '53 BFD'), ('0000ff', '34'), ('0000ff', '31'), ('ff0000', '32'), ('ff0000', '42'), ('8b4513', '8'), ('8b4513', '6'), ('8b4513', '4'), ('8b4513', '25'), ('8b4513', '12'), ('8b4513', '16'), ('ff0000', '16'), ('ff0000', '53 BFD'), ('0000ff', '34'), ('0000ff', '31'), ('ff0000', '32'), ('ff0000', '42'), ('8b4513', '8'), ('8b4513', '6'), ('8b4513', '4'), ('8b4513', '25'), ('8b4513', '12'), ('8b4513', '16'), ('ff0000', '22'), ('ff0000', '53 BFD'), ('ff0000', '36'), ('ff0000', '31'), ('ff0000', '33'), ('ff0000', '32'), ('8b4513', '17'), ('8b4513', '4'), ('8b4513', '2'), ('8b4513', '26'), ('8b4513', '16'), ('8b4513', '7'), ('ff0000', '22'), ('ff0000', '53 BFD'), ('ff0000', '36'), ('ff0000', '31'), ('ff0000', '33'), ('ff0000', '32'), ('8b4513', '17'), ('8b4513', '4'), ('8b4513', '2'), ('8b4513', '26'), ('8b4513', '16'), ('8b4513', '7'), ('bbbb00', '36'), ('bbbb00', '53 BFD'), ('0000ff', '18'), ('0000ff', '32'), ('ff0000', '39'), ('ff0000', '34'), ('8b4513', '3'), ('8b4513', '49'), ('8b4513', '26'), ('8b4513', '6'), ('8b4513', '6'), ('8b4513', '1'), ('bbbb00', '36'), ('bbbb00', '53 BFD'), ('0000ff', '18'), ('0000ff', '32'), ('ff0000', '39'), ('ff0000', '34'), ('8b4513', '3'), ('8b4513', '49'), ('8b4513', '26'), ('8b4513', '6'), ('8b4513', '6'), ('8b4513', '1'), ('bbbb00', '25'), ('bbbb00', '34'), ('bbbb00', '31'), ('bbbb00', '27'), ('0000ff', '33'), ('0000ff', '33'), ('8b4513', '53 UFD'), ('8b4513', '3'), ('8b4513', '17'), ('8b4513', '4'), ('8b4513', '19'), ('8b4513', '18'), ('bbbb00', '25'), ('bbbb00', '34'), ('bbbb00', '31'), ('bbbb00', '27'), ('0000ff', '33'), ('0000ff', '33'), ('8b4513', '53 UFD'), ('8b4513', '3'), ('8b4513', '17'), ('8b4513', '4'), ('8b4513', '19'), ('8b4513', '18'), ('ff0000', '25'), ('ff0000', '53 DSQ'), ('0000ff', '29'), ('0000ff', '42'), ('0000ff', '32'), ('0000ff', '24'), ('8b4513', '10'), ('8b4513', '14'), ('8b4513', '11'), ('8b4513', '17'), ('8b4513', '9'), ('8b4513', '53'), ('ff0000', '25'), ('ff0000', '53 DSQ'), ('0000ff', '29'), ('0000ff', '42'), ('0000ff', '32'), ('0000ff', '24'), ('8b4513', '10'), ('8b4513', '14'), ('8b4513', '11'), ('8b4513', '17'), ('8b4513', '9'), ('8b4513', '53'), ('0000ff', '13'), ('0000ff', '37'), ('ff0000', '29'), ('ff0000', '41'), ('bbbb00', '43'), ('bbbb00', '34'), ('8b4513', '1'), ('8b4513', '33'), ('8b4513', '7'), ('8b4513', '21'), ('8b4513', '28'), ('8b4513', '11'), ('0000ff', '13'), ('0000ff', '37'), ('ff0000', '29'), ('ff0000', '41'), ('bbbb00', '43'), ('bbbb00', '34'), ('8b4513', '1'), ('8b4513', '33'), ('8b4513', '7'), ('8b4513', '21'), ('8b4513', '28'), ('8b4513', '11'), ('bbbb00', '22'), ('bbbb00', '39'), ('ff0000', '41'), ('ff0000', '43'), ('0000ff', '23'), ('0000ff', '38'), ('8b4513', '11'), ('8b4513', '11'), ('8b4513', '21'), ('8b4513', '36'), ('8b4513', '3'), ('8b4513', '12'), ('bbbb00', '22'), ('bbbb00', '39'), ('ff0000', '41'), ('ff0000', '43'), ('0000ff', '23'), ('0000ff', '38'), ('8b4513', '11'), ('8b4513', '11'), ('8b4513', '21'), ('8b4513', '36'), ('8b4513', '3'), ('8b4513', '12'), ('ff0000', '38'), ('ff0000', '53 BFD'), ('ff0000', '37'), ('ff0000', '25'), ('bbbb00', '34'), ('bbbb00', '19'), ('8b4513', '24'), ('8b4513', '22'), ('8b4513', '14'), ('8b4513', '31'), ('8b4513', '14'), ('8b4513', '6'), ('ff0000', '38'), ('ff0000', '53 BFD'), ('ff0000', '37'), ('ff0000', '25'), ('bbbb00', '34'), ('bbbb00', '19'), ('8b4513', '24'), ('8b4513', '22'), ('8b4513', '14'), ('8b4513', '31'), ('8b4513', '14'), ('8b4513', '6'), ('bbbb00', '32'), ('bbbb00', '53 BFD'), ('ff0000', '39'), ('ff0000', '20'), ('bbbb00', '45'), ('bbbb00', '45'), ('8b4513', '15'), ('8b4513', '1'), ('8b4513', '10'), ('8b4513', '16'), ('8b4513', '35'), ('8b4513', '15'), ('bbbb00', '32'), ('bbbb00', '53 BFD'), ('ff0000', '39'), ('ff0000', '20'), ('bbbb00', '45'), ('bbbb00', '45'), ('8b4513', '15'), ('8b4513', '1'), ('8b4513', '10'), ('8b4513', '16'), ('8b4513', '35'), ('8b4513', '15'), ('bbbb00', '44'), ('bbbb00', '22'), ('0000ff', '37'), ('0000ff', '45'), ('ff0000', '41'), ('ff0000', '41'), ('8b4513', '6'), ('8b4513', '20'), ('8b4513', '53 RET'), ('8b4513', '2'), ('8b4513', '5'), ('8b4513', '14'), ('bbbb00', '44'), ('bbbb00', '22'), ('0000ff', '37'), ('0000ff', '45'), ('ff0000', '41'), ('ff0000', '41'), ('8b4513', '6'), ('8b4513', '20'), ('8b4513', '53 RET'), ('8b4513', '2'), ('8b4513', '5'), ('8b4513', '14'), ('0000ff', '45'), ('0000ff', '40'), ('0000ff', '30'), ('0000ff', '37'), ('0000ff', '16'), ('0000ff', '26'), ('8b4513', '28'), ('8b4513', '25'), ('8b4513', '13'), ('8b4513', '20'), ('8b4513', '22'), ('8b4513', '22'), ('0000ff', '45'), ('0000ff', '40'), ('0000ff', '30'), ('0000ff', '37'), ('0000ff', '16'), ('0000ff', '26'), ('8b4513', '28'), ('8b4513', '25'), ('8b4513', '13'), ('8b4513', '20'), ('8b4513', '22'), ('8b4513', '22'), ('0000ff', '50'), ('0000ff', '36'), ('bbbb00', '38'), ('bbbb00', '41'), ('bbbb00', '41'), ('bbbb00', '44'), ('8b4513', '27'), ('8b4513', '9'), ('8b4513', '28'), ('8b4513', '10'), ('8b4513', '7'), ('8b4513', '3'), ('0000ff', '50'), ('0000ff', '36'), ('bbbb00', '38'), ('bbbb00', '41'), ('bbbb00', '41'), ('bbbb00', '44'), ('8b4513', '27'), ('8b4513', '9'), ('8b4513', '28'), ('8b4513', '10'), ('8b4513', '7'), ('8b4513', '3'), ('ff0000', '42'), ('ff0000', '53 BFD'), ('0000ff', '39'), ('0000ff', '47'), ('0000ff', '39'), ('0000ff', '41'), ('8b4513', '5'), ('8b4513', '18'), ('8b4513', '8'), ('8b4513', '22'), ('8b4513', '13'), ('8b4513', '13'), ('ff0000', '42'), ('ff0000', '53 BFD'), ('0000ff', '39'), ('0000ff', '47'), ('0000ff', '39'), ('0000ff', '41'), ('8b4513', '5'), ('8b4513', '18'), ('8b4513', '8'), ('8b4513', '22'), ('8b4513', '13'), ('8b4513', '13'), ('0000ff', '31'), ('0000ff', '39'), ('0000ff', '28'), ('0000ff', '43'), ('0000ff', '37'), ('0000ff', '36'), ('8b4513', '32'), ('8b4513', '7'), ('8b4513', '23'), ('8b4513', '18'), ('8b4513', '24'), ('8b4513', '5'), ('0000ff', '31'), ('0000ff', '39'), ('0000ff', '28'), ('0000ff', '43'), ('0000ff', '37'), ('0000ff', '36'), ('8b4513', '32'), ('8b4513', '7'), ('8b4513', '23'), ('8b4513', '18'), ('8b4513', '24'), ('8b4513', '5'), ('bbbb00', '42'), ('bbbb00', '30'), ('ff0000', '34'), ('ff0000', '39'), ('bbbb00', '33'), ('bbbb00', '43'), ('8b4513', '4'), ('8b4513', '24'), ('8b4513', '27'), ('8b4513', '34'), ('8b4513', '8'), ('8b4513', '9'), ('bbbb00', '42'), ('bbbb00', '30'), ('ff0000', '34'), ('ff0000', '39'), ('bbbb00', '33'), ('bbbb00', '43'), ('8b4513', '4'), ('8b4513', '24'), ('8b4513', '27'), ('8b4513', '34'), ('8b4513', '8'), ('8b4513', '9'), ('ff0000', '28'), ('ff0000', '53 BFD'), ('ff0000', '35'), ('ff0000', '44'), ('bbbb00', '35'), ('bbbb00', '38'), ('8b4513', '26'), ('8b4513', '38'), ('8b4513', '16'), ('8b4513', '19'), ('8b4513', '10'), ('8b4513', '4'), ('ff0000', '28'), ('ff0000', '53 BFD'), ('ff0000', '35'), ('ff0000', '44'), ('bbbb00', '35'), ('bbbb00', '38'), ('8b4513', '26'), ('8b4513', '38'), ('8b4513', '16'), ('8b4513', '19'), ('8b4513', '10'), ('8b4513', '4'), ('bbbb00', '46'), ('bbbb00', '17'), ('bbbb00', '37'), ('bbbb00', '35'), ('0000ff', '42'), ('0000ff', '34'), ('8b4513', '13'), ('8b4513', '23'), ('8b4513', '53 DSQ'), ('8b4513', '15'), ('8b4513', '26'), ('8b4513', '10'), ('bbbb00', '46'), ('bbbb00', '17'), ('bbbb00', '37'), ('bbbb00', '35'), ('0000ff', '42'), ('0000ff', '34'), ('8b4513', '13'), ('8b4513', '23'), ('8b4513', '53 DSQ'), ('8b4513', '15'), ('8b4513', '26'), ('8b4513', '10'), ('ff0000', '4'), ('ff0000', '30'), ('0000ff', '40'), ('0000ff', '39'), ('0000ff', '45'), ('0000ff', '46'), ('8b4513', '12'), ('8b4513', '43'), ('8b4513', '15'), ('8b4513', '12'), ('8b4513', '32'), ('8b4513', '26'), ('ff0000', '4'), ('ff0000', '30'), ('0000ff', '40'), ('0000ff', '39'), ('0000ff', '45'), ('0000ff', '46'), ('8b4513', '12'), ('8b4513', '43'), ('8b4513', '15'), ('8b4513', '12'), ('8b4513', '32'), ('8b4513', '26'), ('0000ff', '39'), ('0000ff', '42'), ('0000ff', '33'), ('0000ff', '38'), ('ff0000', '42'), ('ff0000', '37'), ('8b4513', '23'), ('8b4513', '37'), ('8b4513', '22'), ('8b4513', '1'), ('8b4513', '4'), ('8b4513', '23'), ('0000ff', '39'), ('0000ff', '42'), ('0000ff', '33'), ('0000ff', '38'), ('ff0000', '42'), ('ff0000', '37'), ('8b4513', '23'), ('8b4513', '37'), ('8b4513', '22'), ('8b4513', '1'), ('8b4513', '4'), ('8b4513', '23'), ('bbbb00', '33'), ('bbbb00', '33'), ('bbbb00', '39'), ('bbbb00', '36'), ('ff0000', '44'), ('ff0000', '33'), ('8b4513', '19'), ('8b4513', '8'), ('8b4513', '33'), ('8b4513', '27'), ('8b4513', '18'), ('8b4513', '17'), ('bbbb00', '33'), ('bbbb00', '33'), ('bbbb00', '39'), ('bbbb00', '36'), ('ff0000', '44'), ('ff0000', '33'), ('8b4513', '19'), ('8b4513', '8'), ('8b4513', '33'), ('8b4513', '27'), ('8b4513', '18'), ('8b4513', '17'), ('ff0000', '37'), ('ff0000', '53 BFD'), ('0000ff', '32'), ('0000ff', '46'), ('bbbb00', '40'), ('bbbb00', '42'), ('8b4513', '16'), ('8b4513', '19'), ('8b4513', '9'), ('8b4513', '7'), ('8b4513', '33'), ('8b4513', '25'), ('ff0000', '37'), ('ff0000', '53 BFD'), ('0000ff', '32'), ('0000ff', '46'), ('bbbb00', '40'), ('bbbb00', '42'), ('8b4513', '16'), ('8b4513', '19'), ('8b4513', '9'), ('8b4513', '7'), ('8b4513', '33'), ('8b4513', '25'), ('bbbb00', '10'), ('bbbb00', '53 BFD'), ('0000ff', '42'), ('0000ff', '51.6 DPI'), ('bbbb00', '48'), ('bbbb00', '46'), ('8b4513', '18'), ('8b4513', '30'), ('8b4513', '19'), ('8b4513', '5'), ('8b4513', '29'), ('8b4513', '19'), ('bbbb00', '10'), ('bbbb00', '53 BFD'), ('0000ff', '42'), ('0000ff', '51.6 DPI'), ('bbbb00', '48'), ('bbbb00', '46'), ('8b4513', '18'), ('8b4513', '30'), ('8b4513', '19'), ('8b4513', '5'), ('8b4513', '29'), ('8b4513', '19'), ('0000ff', '35'), ('0000ff', '53 BFD'), ('ff0000', '45'), ('ff0000', '38'), ('ff0000', '38'), ('ff0000', '39'), ('8b4513', '20'), ('8b4513', '5'), ('8b4513', '20'), ('8b4513', '11'), ('8b4513', '15'), ('8b4513', '53'), ('0000ff', '35'), ('0000ff', '53 BFD'), ('ff0000', '45'), ('ff0000', '38'), ('ff0000', '38'), ('ff0000', '39'), ('8b4513', '20'), ('8b4513', '5'), ('8b4513', '20'), ('8b4513', '11'), ('8b4513', '15'), ('8b4513', '53'), ('bbbb00', '43'), ('bbbb00', '36'), ('0000ff', '21'), ('0000ff', '40'), ('ff0000', '22'), ('ff0000', '36'), ('8b4513', '25'), ('8b4513', '10'), ('8b4513', '31'), ('8b4513', '38'), ('8b4513', '27'), ('8b4513', '24'), ('bbbb00', '43'), ('bbbb00', '36'), ('0000ff', '21'), ('0000ff', '40'), ('ff0000', '22'), ('ff0000', '36'), ('8b4513', '25'), ('8b4513', '10'), ('8b4513', '31'), ('8b4513', '38'), ('8b4513', '27'), ('8b4513', '24'), ('ff0000', '44'), ('ff0000', '53 BFD'), ('bbbb00', '44'), ('bbbb00', '44'), ('bbbb00', '47'), ('bbbb00', '40'), ('8b4513', '14'), ('8b4513', '13'), ('8b4513', '6'), ('8b4513', '8'), ('8b4513', '30'), ('8b4513', '29'), ('ff0000', '44'), ('ff0000', '53 BFD'), ('bbbb00', '44'), ('bbbb00', '44'), ('bbbb00', '47'), ('bbbb00', '40'), ('8b4513', '14'), ('8b4513', '13'), ('8b4513', '6'), ('8b4513', '8'), ('8b4513', '30'), ('8b4513', '29'), ('ff0000', '43'), ('ff0000', '31'), ('bbbb00', '45'), ('bbbb00', '43'), ('0000ff', '48'), ('0000ff', '45'), ('8b4513', '2'), ('8b4513', '12'), ('8b4513', '34'), ('8b4513', '13'), ('8b4513', '20'), ('8b4513', '30'), ('ff0000', '43'), ('ff0000', '31'), ('bbbb00', '45'), ('bbbb00', '43'), ('0000ff', '48'), ('0000ff', '45'), ('8b4513', '2'), ('8b4513', '12'), ('8b4513', '34'), ('8b4513', '13'), ('8b4513', '20'), ('8b4513', '30'), ('bbbb00', '15'), ('bbbb00', '26'), ('ff0000', '53 DNF'), ('ff0000', '45'), ('0000ff', '43'), ('0000ff', '39'), ('8b4513', '22'), ('8b4513', '45'), ('8b4513', '32'), ('8b4513', '28'), ('8b4513', '11'), ('8b4513', '20'), ('bbbb00', '15'), ('bbbb00', '26'), ('ff0000', '53 DNF'), ('ff0000', '45'), ('0000ff', '43'), ('0000ff', '39'), ('8b4513', '22'), ('8b4513', '45'), ('8b4513', '32'), ('8b4513', '28'), ('8b4513', '11'), ('8b4513', '20'), ('0000ff', '10'), ('0000ff', '41'), ('0000ff', '38'), ('0000ff', '44'), ('bbbb00', '39'), ('bbbb00', '36'), ('8b4513', '53 RET'), ('8b4513', '32'), ('8b4513', '18'), ('8b4513', '24'), ('8b4513', '21'), ('8b4513', '28'), ('0000ff', '10'), ('0000ff', '41'), ('0000ff', '38'), ('0000ff', '44'), ('bbbb00', '39'), ('bbbb00', '36'), ('8b4513', '53 RET'), ('8b4513', '32'), ('8b4513', '18'), ('8b4513', '24'), ('8b4513', '21'), ('8b4513', '28'), ('ff0000', '41'), ('ff0000', '37'), ('bbbb00', '42'), ('bbbb00', '40'), ('ff0000', '45'), ('ff0000', '43'), ('8b4513', '36'), ('8b4513', '31'), ('8b4513', '24'), ('8b4513', '23'), ('8b4513', '23'), ('8b4513', '27'), ('ff0000', '41'), ('ff0000', '37'), ('bbbb00', '42'), ('bbbb00', '40'), ('ff0000', '45'), ('ff0000', '43'), ('8b4513', '36'), ('8b4513', '31'), ('8b4513', '24'), ('8b4513', '23'), ('8b4513', '23'), ('8b4513', '27'), ('ff0000', '39'), ('ff0000', '53 BFD'), ('bbbb00', '40'), ('bbbb00', '45'), ('bbbb00', '46'), ('bbbb00', '47'), ('8b4513', '31'), ('8b4513', '2'), ('8b4513', '53 RET'), ('8b4513', '14'), ('8b4513', '31'), ('8b4513', '33'), ('ff0000', '39'), ('ff0000', '53 BFD'), ('bbbb00', '40'), ('bbbb00', '45'), ('bbbb00', '46'), ('bbbb00', '47'), ('8b4513', '31'), ('8b4513', '2'), ('8b4513', '53 RET'), ('8b4513', '14'), ('8b4513', '31'), ('8b4513', '33'), ('bbbb00', '39'), ('bbbb00', '38'), ('ff0000', '44'), ('ff0000', '46'), ('0000ff', '47'), ('0000ff', '49'), ('8b4513', '30'), ('8b4513', '15'), ('8b4513', '37'), ('8b4513', '32'), ('8b4513', '34'), ('8b4513', '21'), ('bbbb00', '39'), ('bbbb00', '38'), ('ff0000', '44'), ('ff0000', '46'), ('0000ff', '47'), ('0000ff', '49'), ('8b4513', '30'), ('8b4513', '15'), ('8b4513', '37'), ('8b4513', '32'), ('8b4513', '34'), ('8b4513', '21'), ('ff0000', '34'), ('ff0000', '35'), ('bbbb00', '47'), ('bbbb00', '42'), ('0000ff', '49'), ('0000ff', '47'), ('8b4513', '21'), ('8b4513', '27'), ('8b4513', '38'), ('8b4513', '40'), ('8b4513', '37'), ('8b4513', '34'), ('ff0000', '34'), ('ff0000', '35'), ('bbbb00', '47'), ('bbbb00', '42'), ('0000ff', '49'), ('0000ff', '47'), ('8b4513', '21'), ('8b4513', '27'), ('8b4513', '38'), ('8b4513', '40'), ('8b4513', '37'), ('8b4513', '34'), ('0000ff', '47'), ('0000ff', '44'), ('0000ff', '41'), ('0000ff', '48'), ('0000ff', '46'), ('0000ff', '50'), ('8b4513', '33'), ('8b4513', '17'), ('8b4513', '30'), ('8b4513', '42'), ('8b4513', '25'), ('8b4513', '32'), ('0000ff', '47'), ('0000ff', '44'), ('0000ff', '41'), ('0000ff', '48'), ('0000ff', '46'), ('0000ff', '50'), ('8b4513', '33'), ('8b4513', '17'), ('8b4513', '30'), ('8b4513', '42'), ('8b4513', '25'), ('8b4513', '32'), ('0000ff', '48'), ('0000ff', '45'), ('ff0000', '47'), ('ff0000', '47'), ('0000ff', '41'), ('0000ff', '43'), ('8b4513', '41'), ('8b4513', '35'), ('8b4513', '29'), ('8b4513', '30'), ('8b4513', '17'), ('8b4513', '31'), ('0000ff', '48'), ('0000ff', '45'), ('ff0000', '47'), ('ff0000', '47'), ('0000ff', '41'), ('0000ff', '43'), ('8b4513', '41'), ('8b4513', '35'), ('8b4513', '29'), ('8b4513', '30'), ('8b4513', '17'), ('8b4513', '31'), ('ff0000', '49'), ('ff0000', '33'), ('bbbb00', '49'), ('bbbb00', '48'), ('ff0000', '46'), ('ff0000', '44'), ('8b4513', '40'), ('8b4513', '29'), ('8b4513', '5'), ('8b4513', '43'), ('8b4513', '36'), ('8b4513', '36'), ('ff0000', '49'), ('ff0000', '33'), ('bbbb00', '49'), ('bbbb00', '48'), ('ff0000', '46'), ('ff0000', '44'), ('8b4513', '40'), ('8b4513', '29'), ('8b4513', '5'), ('8b4513', '43'), ('8b4513', '36'), ('8b4513', '36'), ('0000ff', '42'), ('0000ff', '47'), ('bbbb00', '46'), ('bbbb00', '47'), ('0000ff', '50'), ('0000ff', '50.6 DPI'), ('8b4513', '34'), ('8b4513', '16'), ('8b4513', '35'), ('8b4513', '29'), ('8b4513', '38'), ('8b4513', '35'), ('0000ff', '42'), ('0000ff', '47'), ('bbbb00', '46'), ('bbbb00', '47'), ('0000ff', '50'), ('0000ff', '50.6 DPI'), ('8b4513', '34'), ('8b4513', '16'), ('8b4513', '35'), ('8b4513', '29'), ('8b4513', '38'), ('8b4513', '35'), ('bbbb00', '47'), ('bbbb00', '40'), ('0000ff', '36'), ('0000ff', '33'), ('ff0000', '43'), ('ff0000', '35'), ('8b4513', '37'), ('8b4513', '50'), ('8b4513', '36'), ('8b4513', '35'), ('8b4513', '39'), ('8b4513', '37'), ('bbbb00', '47'), ('bbbb00', '40'), ('0000ff', '36'), ('0000ff', '33'), ('ff0000', '43'), ('ff0000', '35'), ('8b4513', '37'), ('8b4513', '50'), ('8b4513', '36'), ('8b4513', '35'), ('8b4513', '39'), ('8b4513', '37'), ('bbbb00', '51'), ('bbbb00', '43'), ('ff0000', '48'), ('ff0000', '48'), ('ff0000', '47'), ('ff0000', '45'), ('8b4513', '35'), ('8b4513', '36'), ('8b4513', '25'), ('8b4513', '33'), ('8b4513', '41'), ('8b4513', '39'), ('bbbb00', '51'), ('bbbb00', '43'), ('ff0000', '48'), ('ff0000', '48'), ('ff0000', '47'), ('ff0000', '45'), ('8b4513', '35'), ('8b4513', '36'), ('8b4513', '25'), ('8b4513', '33'), ('8b4513', '41'), ('8b4513', '39'), ('ff0000', '45'), ('ff0000', '34'), ('bbbb00', '43'), ('bbbb00', '48.6 DPI'), ('bbbb00', '44'), ('bbbb00', '48'), ('8b4513', '39'), ('8b4513', '39'), ('8b4513', '41'), ('8b4513', '37'), ('8b4513', '40'), ('8b4513', '38'), ('ff0000', '45'), ('ff0000', '34'), ('bbbb00', '43'), ('bbbb00', '48.6 DPI'), ('bbbb00', '44'), ('bbbb00', '48'), ('8b4513', '39'), ('8b4513', '39'), ('8b4513', '41'), ('8b4513', '37'), ('8b4513', '40'), ('8b4513', '38'), ('0000ff', '49'), ('0000ff', '48'), ('0000ff', '53 BFD'), ('0000ff', '50'), ('ff0000', '48'), ('ff0000', '46'), ('8b4513', '29'), ('8b4513', '41'), ('8b4513', '39'), ('8b4513', '39'), ('8b4513', '47'), ('8b4513', '41'), ('0000ff', '49'), ('0000ff', '48'), ('0000ff', '53 BFD'), ('0000ff', '50'), ('ff0000', '48'), ('ff0000', '46'), ('8b4513', '29'), ('8b4513', '41'), ('8b4513', '39'), ('8b4513', '39'), ('8b4513', '47'), ('8b4513', '41'), ('ff0000', '52'), ('ff0000', '36'), ('ff0000', '49'), ('ff0000', '49'), ('bbbb00', '50'), ('bbbb00', '51'), ('8b4513', '38'), ('8b4513', '26'), ('8b4513', '46'), ('8b4513', '47'), ('8b4513', '48'), ('8b4513', '43'), ('ff0000', '52'), ('ff0000', '36'), ('ff0000', '49'), ('ff0000', '49'), ('bbbb00', '50'), ('bbbb00', '51'), ('8b4513', '38'), ('8b4513', '26'), ('8b4513', '46'), ('8b4513', '47'), ('8b4513', '48'), ('8b4513', '43'), ('ff0000', '50'), ('ff0000', '32'), ('bbbb00', '50'), ('bbbb00', '51'), ('ff0000', '49'), ('ff0000', '47'), ('8b4513', '42'), ('8b4513', '34'), ('8b4513', '45'), ('8b4513', '44'), ('8b4513', '49'), ('8b4513', '42'), ('ff0000', '50'), ('ff0000', '32'), ('bbbb00', '50'), ('bbbb00', '51'), ('ff0000', '49'), ('ff0000', '47'), ('8b4513', '42'), ('8b4513', '34'), ('8b4513', '45'), ('8b4513', '44'), ('8b4513', '49'), ('8b4513', '42'), ('bbbb00', '50'), ('bbbb00', '42'), ('bbbb00', '52'), ('bbbb00', '52'), ('ff0000', '50'), ('ff0000', '49'), ('8b4513', '43'), ('8b4513', '42'), ('8b4513', '42'), ('8b4513', '41'), ('8b4513', '45'), ('8b4513', '48'), ('bbbb00', '50'), ('bbbb00', '42'), ('bbbb00', '52'), ('bbbb00', '52'), ('ff0000', '50'), ('ff0000', '49'), ('8b4513', '43'), ('8b4513', '42'), ('8b4513', '42'), ('8b4513', '41'), ('8b4513', '45'), ('8b4513', '48'), ('0000ff', '46'), ('0000ff', '46'), ('0000ff', '44'), ('0000ff', '52'), ('ff0000', '51'), ('ff0000', '48'), ('8b4513', '45'), ('8b4513', '40'), ('8b4513', '40'), ('8b4513', '49'), ('8b4513', '51'), ('8b4513', '45'), ('0000ff', '46'), ('0000ff', '46'), ('0000ff', '44'), ('0000ff', '52'), ('ff0000', '51'), ('ff0000', '48'), ('8b4513', '45'), ('8b4513', '40'), ('8b4513', '40'), ('8b4513', '49'), ('8b4513', '51'), ('8b4513', '45'), ('bbbb00', '52'), ('bbbb00', '44'), ('bbbb00', '48'), ('bbbb00', '49'), ('bbbb00', '49'), ('bbbb00', '49'), ('8b4513', '49'), ('8b4513', '47'), ('8b4513', '48'), ('8b4513', '45'), ('8b4513', '42'), ('8b4513', '40'), ('bbbb00', '52'), ('bbbb00', '44'), ('bbbb00', '48'), ('bbbb00', '49'), ('bbbb00', '49'), ('bbbb00', '49'), ('8b4513', '49'), ('8b4513', '47'), ('8b4513', '48'), ('8b4513', '45'), ('8b4513', '42'), ('8b4513', '40'), ('bbbb00', '49'), ('bbbb00', '41'), ('ff0000', '50'), ('ff0000', '51'), ('bbbb00', '51'), ('bbbb00', '50'), ('8b4513', '47'), ('8b4513', '46'), ('8b4513', '47'), ('8b4513', '48'), ('8b4513', '43'), ('8b4513', '44'), ('bbbb00', '49'), ('bbbb00', '41'), ('ff0000', '50'), ('ff0000', '51'), ('bbbb00', '51'), ('bbbb00', '50'), ('8b4513', '47'), ('8b4513', '46'), ('8b4513', '47'), ('8b4513', '48'), ('8b4513', '43'), ('8b4513', '44'), ('bbbb00', '40'), ('bbbb00', '16'), ('0000ff', '53 BFD'), ('0000ff', '41'), ('ff0000', '53 DNC'), ('ff0000', '53 DNC'), ('8b4513', '53 DNC'), ('8b4513', '53 DNC'), ('8b4513', '53 DNC'), ('8b4513', '53 DNC'), ('8b4513', '53 DNC'), ('8b4513', '53'), ('bbbb00', '40'), ('bbbb00', '16'), ('0000ff', '53 BFD'), ('0000ff', '41'), ('ff0000', '53 DNC'), ('ff0000', '53 DNC'), ('8b4513', '53 DNC'), ('8b4513', '53 DNC'), ('8b4513', '53 DNC'), ('8b4513', '53 DNC'), ('8b4513', '53 DNC'), ('8b4513', '53'), ('0000ff', '51'), ('0000ff', '50'), ('bbbb00', '51'), ('bbbb00', '50'), ('bbbb00', '52'), ('bbbb00', '52'), ('8b4513', '46'), ('8b4513', '44'), ('8b4513', '43'), ('8b4513', '46'), ('8b4513', '44'), ('8b4513', '53'), ('0000ff', '51'), ('0000ff', '50'), ('bbbb00', '51'), ('bbbb00', '50'), ('bbbb00', '52'), ('bbbb00', '52'), ('8b4513', '46'), ('8b4513', '44'), ('8b4513', '43'), ('8b4513', '46'), ('8b4513', '44'), ('8b4513', '53'), ('ff0000', '48'), ('ff0000', '53 BFD'), ('ff0000', '51'), ('ff0000', '50'), ('0000ff', '51'), ('0000ff', '52'), ('8b4513', '48'), ('8b4513', '48'), ('8b4513', '44'), ('8b4513', '50'), ('8b4513', '46'), ('8b4513', '47'), ('ff0000', '48'), ('ff0000', '53 BFD'), ('ff0000', '51'), ('ff0000', '50'), ('0000ff', '51'), ('0000ff', '52'), ('8b4513', '48'), ('8b4513', '48'), ('8b4513', '44'), ('8b4513', '50'), ('8b4513', '46'), ('8b4513', '47'), ('0000ff', '52'), ('0000ff', '49'), ('0000ff', '43'), ('0000ff', '51'), ('0000ff', '52'), ('0000ff', '51'), ('8b4513', '44'), ('8b4513', '51'), ('8b4513', '49'), ('8b4513', '51'), ('8b4513', '50'), ('8b4513', '46'), ('0000ff', '52'), ('0000ff', '49'), ('0000ff', '43'), ('0000ff', '51'), ('0000ff', '52'), ('0000ff', '51'), ('8b4513', '44'), ('8b4513', '51'), ('8b4513', '49'), ('8b4513', '51'), ('8b4513', '50'), ('8b4513', '46')]\n\ndef blah():\n tstname='worldChamps2019.csv'\n\n df = pd.read_csv(tstname)\n\n # for index, row in df.iterrows():\n # print (index, row[5])\n\n # df.columns = df.iloc[1]\n\n # print (df.columns, '\\n')\n\n # print(df.columns[0]==1,'\\n')\n\n # df.drop(columns=[1, 'Pos','Bow#'], inplace=True)\n # df.dropna(axis = 1,inplace=True)\n # df.drop_duplicates(inplace=True)\n\n # for index, row in df.iterrows():\n # df['Name'][index] = ' '.join(reversed(row['Name'].split(' ')))\n\n QR1_blue = []\n QR1_red = []\n QR1_yellow = []\n\n QR2_blue = []\n QR2_red = []\n QR2_yellow = []\n\n QR3_blue = []\n QR3_red = []\n QR3_yellow = []\n\n QR4_blue = []\n QR4_red = []\n QR4_yellow = []\n\n QR5_blue = []\n QR5_red = []\n QR5_yellow = []\n\n QR6_blue = []\n QR6_red = []\n QR6_yellow = []\n\n FR7_gold = []\n FR7_silver = []\n FR7_bronze = []\n\n FR8_gold = []\n FR8_silver = []\n FR8_bronze = []\n\n FR9_gold = []\n FR9_silver = []\n FR9_bronze = []\n\n FR10_gold = []\n FR10_silver = []\n FR10_bronze = []\n\n FR11_gold = []\n FR11_silver = []\n FR11_bronze = []\n\n FR12_gold = []\n FR12_silver = []\n FR12_bronze = []\n\n\n lstQRs=[ QR1_blue , \\\n QR1_red , \\\n QR1_yellow , \\\n\n QR2_blue , \\\n QR2_red , \\\n QR2_yellow , \\\n\n QR3_blue , \\\n QR3_red , \\\n QR3_yellow , \\\n\n QR4_blue , \\\n QR4_red , \\\n QR4_yellow , \\\n\n QR5_blue , \\\n QR5_red , \\\n QR5_yellow , \\\n\n QR6_blue , \\\n QR6_red , \\\n QR6_yellow]\n\n lstFRs=[ FR7_gold , \\\n FR7_silver , \\\n FR7_bronze , \\\n\n FR8_gold , \\\n FR8_silver , \\\n FR8_bronze , \\\n\n FR9_gold , \\\n FR9_silver , \\\n FR9_bronze , \\\n\n FR10_gold , \\\n FR10_silver , \\\n FR10_bronze , \\\n\n FR11_gold , \\\n FR11_silver , \\\n FR11_bronze , \\\n\n FR12_gold , \\\n FR12_silver , \\\n FR12_bronze ]\n\n\n\n colors = {'0000ff': 'blue', 'bbbb00': 'yellow', '999900': 'gold', \n 'ff0000': 'red', '999999':'silver', '8b4513': 'bronze'}\n\n for index, row in df.iterrows():\n lstIndex = index*24\n # if int(colorlst[lstIndex][1]) == int(row['QR1']):\n # print(('{:39} scored '+str(row['QR1']) + '\\t in QR1'\\\n # ' with color code ' + colors.get(colorlst[lstIndex][0])).format(row['Name']) )\n colorKey = colorlst[lstIndex][0]\n if colors.get(colorKey) == 'blue':\n QR1_blue.append([row['Name'],row['QR1']])\n QR2_blue.append([row['Name'],row['QR2']])\n elif colors.get(colorKey) == 'red':\n QR1_red.append([row['Name'],row['QR1']])\n QR2_red.append([row['Name'],row['QR2']])\n elif colors.get(colorKey) == 'yellow':\n QR1_yellow.append([row['Name'],row['QR1']])\n QR2_yellow.append([row['Name'],row['QR2']])\n \n lstIndex += 2\n colorKey = colorlst[lstIndex][0]\n if colors.get(colorKey) == 'blue':\n QR3_blue.append([row['Name'],row['QR3']])\n QR4_blue.append([row['Name'],row['QR4']])\n elif colors.get(colorKey) == 'red':\n QR3_red.append([row['Name'],row['QR3']])\n QR4_red.append([row['Name'],row['QR4']])\n elif colors.get(colorKey) == 'yellow':\n QR3_yellow.append([row['Name'],row['QR3']])\n QR4_yellow.append([row['Name'],row['QR4']])\n\n lstIndex += 2\n colorKey = colorlst[lstIndex][0]\n if colors.get(colorKey) == 'blue':\n QR5_blue.append([row['Name'],row['QR5']])\n QR6_blue.append([row['Name'],row['QR6']])\n elif colors.get(colorKey) == 'red':\n QR5_red.append([row['Name'],row['QR5']])\n QR6_red.append([row['Name'],row['QR6']])\n elif colors.get(colorKey) == 'yellow':\n QR5_yellow.append([row['Name'],row['QR5']])\n QR6_yellow.append([row['Name'],row['QR6']])\n\n lstIndex += 2\n colorKey = colorlst[lstIndex][0]\n if colors.get(colorKey) == 'gold':\n FR7_gold.append([row['Name'],row['FR7']])\n FR8_gold.append([row['Name'],row['FR8']])\n FR9_gold.append([row['Name'],row['FR9']])\n FR10_gold.append([row['Name'],row['FR10']])\n FR11_gold.append([row['Name'],row['FR11']])\n FR12_gold.append([row['Name'],row['FR12']])\n elif colors.get(colorKey) == 'silver':\n FR7_silver.append([row['Name'],row['FR7']])\n FR8_silver.append([row['Name'],row['FR8']])\n FR9_silver.append([row['Name'],row['FR9']])\n FR10_silver.append([row['Name'],row['FR10']])\n FR11_silver.append([row['Name'],row['FR11']])\n FR12_silver.append([row['Name'],row['FR12']])\n elif colors.get(colorKey) == 'bronze':\n FR7_bronze.append([row['Name'],row['FR7']])\n FR8_bronze.append([row['Name'],row['FR8']])\n FR9_bronze.append([row['Name'],row['FR9']])\n FR10_bronze.append([row['Name'],row['FR10']])\n FR11_bronze.append([row['Name'],row['FR11']])\n FR12_bronze.append([row['Name'],row['FR12']])\n\n indexColors = {0:'blue', 1:'red', 2:'yellow'}\n for i in range(18):\n \n qr = lstQRs[i]\n qr.sort(key = lambda sailor:sailor[1])\n currentColor = indexColors.get(i % 3)\n QRnum = int(i / 3) + 1\n\n print(qr)\n\n for j in range(len(qr)):\n result = qr[j]\n sailor = result[0]\n rr = result[1]\n sailorIndex = df.loc[df['Name']==sailor].index\n\n colName = 'QR{}_{}'.format(str(QRnum),str(currentColor))\n print (\"{:39} had result {:3} in race {}\".format(\\\n sailor,rr,colName))\n try:\n df.at[sailorIndex,colName] = rr\n except Exception as e:\n df[colName] = np.nan\n df.at[sailorIndex,colName] = rr\n\n indexColors = {0:'gold', 1:'silver', 2:'bronze'}\n for i in range(18):\n \n fr = lstFRs[i]\n fr.sort(key = lambda sailor:sailor[1])\n currentColor = indexColors.get(i % 3)\n FRnum = int(i / 3) + 1\n\n print(fr)\n\n for j in range(len(fr)):\n result = fr[j]\n sailor = result[0]\n rr = result[1]\n sailorIndex = df.loc[df['Name']==sailor].index\n\n colName = 'FR{}_{}'.format(str(FRnum + 6),str(currentColor))\n print (\"{:39} had result {:3} in race {}\".format(\\\n sailor,rr,colName))\n try:\n df.at[sailorIndex,colName] = rr\n except Exception as e:\n df[colName] = np.nan\n df.at[sailorIndex,colName] = rr\n\n\n\n\n\n df.to_csv('MOD' + tstname, index=False)\n\n#rawHTML=\"\"\"\"\"\"\n\ndef blah2():\n Regex=re.compile(r'color=\" #([0-9a-f]{6})\">(?:<s>)?(\\d{1,2}\|\\d{1,2}\\.?\\d?\\s[A-Z]{3})\\s?(?:<\\/s>)?<\\/font><\\/td>')\n print(Regex.findall(rawHTML))\n\n\n\n\ndef wc2020():\n df = pd.read_csv('WorldChamps2020.csv')\n\n # colors = {0:'yellow',1:'blue',2:'red'}\n # for i in range(1,7):\n # for j in range(3):\n # inputFile = 'WorldChamps2020R{}{}'.format(str(i),str(j))\n # dfTmp = pd.read_csv(inputFile + '.csv')\n # colName = 'QR{}_{}'.format(str(i),colors.get(j))\n\n # for index, row in dfTmp.iterrows():\n # sailor = row['Name'].replace(u'\\xa0', u' ')\n # rr = row['Points']\n # dfIndex = df.loc[df['Name']==sailor].index\n # try:\n # df.at[dfIndex,colName] = rr\n # except Exception as e:\n # df[colName] = np.nan\n # df.at[dfIndex,colName] = rr\n\n # colors = {0:'gold',1:'silver',2:'bronze'}\n # for i in range(7,13):\n # for j in range(3):\n # inputFile = 'WorldChamps2020R{}{}'.format(str(i),colors.get(j))\n # dfTmp = pd.read_csv(inputFile + '.csv')\n # colName = 'FR{}_{}'.format(str(i),colors.get(j))\n\n # for index, row in dfTmp.iterrows():\n # sailor = row['Name'].replace(u'\\xa0', u' ')\n # rr = row['Points']\n # dfIndex = df.loc[df['Name']==sailor].index\n # try:\n # df.at[dfIndex,colName] = rr\n # except Exception as e:\n # df[colName] = np.nan\n # df.at[dfIndex,colName] = rr\n\n # df.to_csv('WorldChamps2020Entries.csv',index=False)\n\n #df['Total'] = df.iloc[:,5:].sum(axis=1)\n #print(df['Total'])\n\n # df['Net'] = df['Total'] - df.iloc[:,5:18+4+1].max(axis=1) \\\n # - df.iloc[:,18+4+1:].max(axis=1)\n\n # print(df.at[3,'FR12_bronze'])\n # for index, row in df.iterrows():\n # #print(row['FR12_gold'])\n # if str(row['FR12_gold']) != 'nan':\n # df.at[index,'fleet'] = 1\n # elif str(row['FR12_silver']) != 'nan':\n # df.at[index,'fleet'] = 2\n # else:\n # df.at[index,'fleet'] = 3\n\n #df.sort_values(['fleet','Net'],inplace=True)\n\n #print( tabulate(df, headers='keys', tablefmt='psql'))\n\n df.to_csv('WorldChamps2020.csv',index=False)\n \ndef hempelWCmiami2019():\n df = pd.read_csv('HempelWCMiami2019Overall.csv')\n races = ['QR1_yellow','QR2_yellow','QR3_blue','QR4_blue','FR5_gold','FR6_gold','FR7_gold','FR8_gold','FR9_gold','FR10_gold','FR11_gold','FR_medal','QR3_yellow','QR4_yellow','QR1_blue','QR2_blue','FR5_silver','FR6_silver','FR7_silver','FR8_silver','FR9_silver','FR10_silver']\n\n for race in races:\n inputFile = 'HempelWCMiami2019{}.csv'.format(race)\n dfTmp = pd.read_csv(inputFile)\n\n for index, row in dfTmp.iterrows():\n sailor = row['Crew']\n rr = row['Race Points']\n dfIndex = df.loc[df['Name']==sailor].index\n try:\n df.at[dfIndex,race] = rr\n except Exception as e:\n df[race] = np.nan\n df.at[dfIndex,race] = rr\n\n df.to_csv('HempelWCMiami2019.csv')\n \n\n\n##### main ########\nhempelWCmiami2019()" ]	[ [ "pandas.read_csv" ] ]
jz5jx/Test_Repo	[ "8796f45021943984ed02232fd34ff02e17123d71" ]	[ "src/clustar_project/graph.py" ]	[ "import numpy as np\nimport matplotlib.pyplot as plt\nfrom matplotlib.patches import Rectangle\n\n\ndef identify_peaks(image, smoothing=5, clip=0.75):\n n_rows = image.shape[0]\n n_cols = image.shape[1]\n mid = n_rows // 2\n\n y = np.array([image[mid, c] for c in range(n_cols)])\n x = np.arange(0, len(y), 1)\n\n y_avg = []\n for i in range(len(y)):\n if i + smoothing > y.shape[0]:\n smoothing -= - 1\n if smoothing != 0:\n y_avg.append(np.mean(y[i:i + smoothing]))\n\n y = np.array(y_avg)\n dydx = np.diff(y) / np.diff(x)\n\n lhs = np.array([y[i - 1] / y[i] for i in\n range(1, len(y) // 2) if y[i] != 0])\n lhs[lhs < clip] = 0\n lhs = np.nonzero(lhs)[0]\n lhs = [lhs[i - 1] for i in range(1, len(lhs))\n if ((lhs[i] - lhs[i - 1]) == 1)]\n\n rhs = np.array([y[i] / y[i - 1] for i in\n range(len(y) - 1, len(y) // 2, -1)\n if y[i - 1] != 0])\n rhs[rhs < clip] = 0\n rhs = np.nonzero(rhs)[0]\n rhs = [rhs[i - 1] for i in\n range(1, len(rhs)) if ((rhs[i] - rhs[i - 1]) == 1)]\n\n idx = []\n\n if len(lhs) > 1 and len(rhs) > 1:\n dydx_ = dydx[lhs[0]:-rhs[0]]\n\n if len(dydx_) > 2:\n idx = np.array([i for i in range(1, len(dydx_))\n if (dydx_[i - 1] > 0 >= dydx_[i])\n or (dydx_[i - 1] < 0 <= dydx_[i])]) + lhs[0]\n\n idx = [idx[i] for i, val in enumerate(idx) if i % 2 == 0]\n\n return idx\n" ]	[ [ "numpy.array", "numpy.diff", "numpy.mean", "numpy.nonzero" ] ]
sjanzou/pvlib-python	[ "17751ca69f271891ee83082772b3261138e34dd0" ]	[ "pvlib/test/test_surfrad.py" ]	[ "import inspect\nimport os\n\nfrom pandas import Timestamp, DatetimeIndex\nfrom pandas.util.testing import network\n\nfrom pvlib.iotools import surfrad\n\ntest_dir = os.path.dirname(\n os.path.abspath(inspect.getfile(inspect.currentframe())))\ntestfile = os.path.join(test_dir, '../data/surfrad-slv16001.dat')\nnetwork_testfile = ('ftp://aftp.cmdl.noaa.gov/data/radiation/surfrad/'\n 'Alamosa_CO/2016/slv16001.dat')\n\n\n@network\ndef test_read_surfrad_network():\n # If this test begins failing, SURFRAD's data structure or data\n # archive may have changed.\n local_data, _ = surfrad.read_surfrad(testfile)\n network_data, _ = surfrad.read_surfrad(network_testfile)\n assert local_data.equals(network_data)\n\n\ndef test_read_surfrad_columns_no_map():\n data, _ = surfrad.read_surfrad(testfile, map_variables=False)\n assert 'zen' in data.columns\n assert 'temp' in data.columns\n assert 'par' in data.columns\n assert 'pressure' in data.columns\n\n\ndef test_read_surfrad_columns_map():\n data, _ = surfrad.read_surfrad(testfile)\n assert 'solar_zenith' in data.columns\n assert 'ghi' in data.columns\n assert 'ghi_flag' in data.columns\n assert 'dni' in data.columns\n assert 'dni_flag' in data.columns\n assert 'dhi' in data.columns\n assert 'dhi_flag' in data.columns\n assert 'wind_direction' in data.columns\n assert 'wind_direction_flag' in data.columns\n assert 'wind_speed' in data.columns\n assert 'wind_speed_flag' in data.columns\n assert 'temp_air' in data.columns\n assert 'temp_air_flag' in data.columns\n\n\ndef test_format_index():\n start = Timestamp('20160101 00:00')\n expected = DatetimeIndex(start=start, periods=1440, freq='1min', tz='UTC')\n actual, _ = surfrad.read_surfrad(testfile)\n assert actual.index.equals(expected)\n\n\ndef test_read_surfrad_metadata():\n expected = {'name': 'Alamosa',\n 'latitude': 37.70,\n 'longitude': 105.92,\n 'elevation': 2317,\n 'surfrad_version': 1,\n 'tz': 'UTC'}\n _, metadata = surfrad.read_surfrad(testfile)\n assert metadata == expected\n" ]	[ [ "pandas.Timestamp", "pandas.DatetimeIndex" ] ]

nicolay-r/attitude-extraction-with-attention-and-ds

[ "fb8e9d0d9488363738a88c4c447c7a8cb3e2ec1d" ]

[ "rusentrel/classic/ctx/att_hidden_z_yang.py" ]

[ "#!/usr/bin/python\n# -*- coding: utf-8 -*-\nimport sys\nimport tensorflow as tf\n\n\nsys.path.append('../../../')\n\nfrom io_utils import RuSentRelBasedExperimentsIOUtils\nfrom arekit.contrib.networks.context.architectures.att_self_z_yang_bilstm import AttentionSelfZYangBiLSTM\nfrom arekit.contrib.networks.context.configurations.att_self_z_yang_bilstm import AttentionSelfZYangBiLSTMConfig\nfrom arekit.common.evaluation.evaluators.two_class import TwoClassEvaluator\nfrom arekit.contrib.experiments.nn_io.rusentrel import RuSentRelBasedNeuralNetworkIO\nfrom arekit.contrib.experiments.single.model import SingleInstanceTensorflowModel\n\nfrom rusentrel.ctx_names import ModelNames\nfrom arekit.contrib.experiments.engine import run_testing\nfrom arekit.contrib.experiments.callback import CustomCallback\n\nfrom rusentrel.classic.common import \\\n classic_ctx_common_config_settings, \\\n classic_common_callback_modification_func\n\n\ndef ctx_att_hidden_zyang_bilstm_custom_config(config):\n assert(isinstance(config, AttentionSelfZYangBiLSTMConfig))\n config.modify_bags_per_minibatch(2)\n config.modify_weight_initializer(tf.contrib.layers.xavier_initializer())\n\n\ndef run_testing_att_hidden_zyang_bilstm(name_prefix=u'',\n cv_count=1,\n custom_config_func=ctx_att_hidden_zyang_bilstm_custom_config,\n custom_callback_func=classic_common_callback_modification_func):\n\n run_testing(full_model_name=name_prefix + ModelNames().AttSelfZYangBiLSTM,\n create_network=AttentionSelfZYangBiLSTM,\n create_config=AttentionSelfZYangBiLSTMConfig,\n create_nn_io=RuSentRelBasedNeuralNetworkIO,\n cv_count=cv_count,\n create_model=SingleInstanceTensorflowModel,\n evaluator_class=TwoClassEvaluator,\n create_callback=CustomCallback,\n experiments_io=RuSentRelBasedExperimentsIOUtils(),\n common_callback_modification_func=custom_callback_func,\n custom_config_modification_func=custom_config_func,\n common_config_modification_func=classic_ctx_common_config_settings)\n\n\nif __name__ == \"__main__\":\n\n run_testing_att_hidden_zyang_bilstm()\n" ]

[ [ "tensorflow.contrib.layers.xavier_initializer" ] ]

mvpmanish/LASED

[ "7793037b3e77ee9205f631d7ff6c511895108400" ]

[ "base-LASED/build/lib/LASED/time_evolution_matrix.py" ]

[ "'''\nThis is a file to define a function to populate the time evolution matrix for a laser-atom system\nAuthor: Manish Patel\nDate created: 12/05/2021\n'''\n\nfrom LASED.state import *\nfrom LASED.detuning import *\nfrom LASED.symbolic_print import *\nfrom LASED.half_rabi_freq import *\nfrom LASED.decay_constant import *\nfrom LASED.index import *\n\nfrom sympy import *\nfrom sympy import Symbol\nimport numpy as np\n\ndef timeEvolutionMatrix(n, E, G, Q, Q_decay, tau, laser_wavelength, laser_intensity,\n tau_f = None, detuning = None, symbolic_print = None, numeric_print = None,\n rabi_scaling = None, rabi_factors = None, atomic_velocity = None):\n \"\"\"Function to create and populate the coupled differential equation matrix A for the laser-atom system.\n \n Returns:\n ndarray: Matrix which contains all thera coefficients for the set of coupled differential equations describing a laser-atom system. \n \"\"\"\n \n # Initialise matrix with zeros\n A = np.zeros((n*n,n*n), dtype = np.complex)\n \n # Calculate half-Rabi frequency\n rabi = halfRabiFreq(laser_intensity, tau, laser_wavelength)\n if(rabi_scaling != None): # For normalising the rabi frequency\n rabi = rabi*rabi_scaling\n else:\n rabi_scaling = 1 # For symbolic printing\n \n if(rabi_factors != None):\n if(len(rabi_factors) != len(Q)):\n print(\"rabi_factors must be the same length as Q! Each element of Q is multiplied by the corresponding rabi_factor.\")\n else:\n rabi_factors = [1 for q in Q] # Set Rabi factors to 1\n \n # Initialise null parameters\n if(atomic_velocity == None):\n atomic_velocity = 0\n \n # Populate A matrix\n rho_ggpp(A, n, E, G, Q, Q_decay, tau, rabi, rabi_factors, numeric_print = numeric_print)\n rho_eepp(A, n, E, G, Q, Q_decay, tau, rabi, rabi_factors, tau_f = tau_f, numeric_print = numeric_print)\n rho_ge(A, n, E, G, Q, Q_decay, tau, rabi, rabi_factors, laser_wavelength, atomic_velocity, tau_f = tau_f, detuning = detuning, numeric_print = numeric_print)\n rho_eg(A, n, E, G, Q, Q_decay, tau, rabi, rabi_factors, laser_wavelength, atomic_velocity, tau_f = tau_f, detuning = detuning, numeric_print = numeric_print)\n\n # Symbolic Printing\n if(symbolic_print == True):\n init_printing()\n symbolicPrintSystem(n, E, G, Q, Q_decay, tau_f, detuning, \n laser_wavelength, atomic_velocity, rabi_scaling, rabi_factors)\n \n return A\n\ndef rho_ggpp(A, n, E, G, Q, Q_decay, tau, rabi, rabi_factors, numeric_print = None):\n \"\"\" Function to populate the matrix A with coefficients for populations and atomic coherences of the ground states. \n \"\"\"\n # rho_gg''\n for g in G: # Start with looping over g and g'' for rho_gg''\n for gpp in G:\n row = index(g, gpp, n) # matrix positions of rho_gg'' in 1D array\n A[row, row] += -1.j*delta(g, gpp) # first term in equation\n for e in E:\n column = index(g, e, n)\n for i,q in enumerate(Q): # Sum over all polarisations\n A[row, column] += coupling(e, gpp, q)*1.j*rabi*rabi_factors[i]\n for e in E:\n column = index(e, gpp, n)\n for i,q in enumerate(Q): \n A[row, column] += -1.j*coupling(e, g, q)*rabi*rabi_factors[i]\n for ep in E:\n for epp in E:\n column = index(epp, ep, n)\n column2 = index(ep, epp, n)\n sum_decay_channels = 0\n for gp in G:\n for qp in Q_decay: # Sum over decay channel polarisations\n sum_decay_channels += abs(coupling(epp, gp, qp)*coupling(ep, gp, qp))\n if(sum_decay_channels != 0):\n if(ep.label == epp.label):\n for qp in Q_decay:\n A[row, column] += 1/(2*tau)*abs(coupling(ep, gpp, qp)*coupling(epp,g, qp))/sum_decay_channels\n A[row, column2] += 1/(2*tau)*abs(coupling(epp, gpp, qp)*coupling(ep, g, qp))/sum_decay_channels\n else: \n # Then this is a vertical coherence and the generalised decay constant must be evaluated\n decay_const = generalisedDecayConstant(ep, epp, gpp, G, Q_decay)/(2*tau) # Divide by two to take into account double counting of e'e'' and e''e'\n A[row, column] += decay_const\n A[row, column2] += decay_const\n \n if(numeric_print == True): # Print numerical equations\n print(\"rho_dot\", g.label, gpp.label, \" = \")\n for line in range(n*n):\n if (A[row, line] != 0):\n print(A[row, line], \"rho\", getStateLabelsFromLineNo(line, n))\n\ndef rho_eepp(A, n, E, G, Q, Q_decay, tau, rabi, rabi_factors, tau_f = None, numeric_print = None):\n \"\"\" Function to populate the matrix A with coefficients for populations and atomic coherences of the excited states. \n \"\"\"\n # rho_ee''\n for e in E:\n for epp in E:\n row = index(e, epp, n)\n A[row, row] += -1.j*delta(e, epp) - 1/(tau)\n if(tau_f != None):\n A[row, row] -= 1/tau_f\n for g in G:\n column = index(e, g, n)\n for i,q in enumerate(Q):\n A[row, column] += 1.j*coupling(epp, g, q)*rabi*rabi_factors[i]\n for g in G:\n column = index(g, epp, n)\n for i,q in enumerate(Q): \n A[row, column] += -1.j*coupling(e, g, q)*rabi*rabi_factors[i]\n if(numeric_print == True):\n print(\"rho_dot\", e.label, epp.label, \" = \")\n for line in range(n*n):\n if (A[row, line] != 0):\n print(A[row, line], \"rho\", getStateLabelsFromLineNo(line, n))\n\ndef rho_ge(A, n, E, G, Q, Q_decay, tau, rabi, rabi_factors, laser_wavelength, atomic_velocity, tau_f = None, detuning = None, numeric_print = None):\n \"\"\" Function to populate the matrix A with coefficients for optical coherences between ground and excited states. \n \"\"\"\n # rho_ge\n for g in G:\n for e in E: \n row = index(g, e, n)\n A[row, row] += -1.j*dopplerDelta(e, g, w_q = angularFreq(laser_wavelength),\n lambda_q = laser_wavelength, v_z = atomic_velocity) - 1/(2*tau)\n if(detuning != None):\n A[row, row] += -1.j*detuning\n if(tau_f != None):\n A[row, row] -= 1/(2*tau_f)\n for ep in E:\n column = index(ep, e, n)\n for i,q in enumerate(Q): \n A[row, column] += -1.j*coupling(ep, g, q)*rabi*rabi_factors[i]\n for gp in G:\n column = index(g, gp, n)\n for i,q in enumerate(Q): \n A[row, column] += 1.j*coupling(e, gp, q)*rabi*rabi_factors[i]\n if(numeric_print == True):\n print(\"rho_dot\", g.label, e.label, \" = \")\n for line in range(n*n):\n if (A[row, line] != 0):\n print(A[row, line], \"rho\", getStateLabelsFromLineNo(line, n))\n\ndef rho_eg(A, n, E, G, Q, Q_decay, tau, rabi, rabi_factors, laser_wavelength, atomic_velocity, tau_f = None, detuning = None, numeric_print = None):\n \"\"\" Function to populate the matrix A with coefficients for optical coherences between excited and ground states. \n \"\"\"\n # rho_eg\n for e in E:\n for g in G: \n row = index(e, g, n)\n A[row, row] += 1.j*dopplerDelta(e, g, w_q = angularFreq(laser_wavelength), \n lambda_q = laser_wavelength, v_z = atomic_velocity) - 1/(2*tau)\n if(detuning != None):\n A[row, row] += 1.j*detuning\n if(tau_f != None):\n A[row, row] -= 1/(2*tau_f)\n for ep in E:\n column = index(e, ep, n)\n for i,q in enumerate(Q): \n A[row, column] += 1.j*coupling(ep, g, q)*rabi*rabi_factors[i]\n for gp in G:\n column = index(gp, g, n)\n for i,q in enumerate(Q): \n A[row, column] += -1.j*coupling(e, gp, q)*rabi*rabi_factors[i]\n if(numeric_print == True):\n print(\"rho_dot\", e.label, g.label, \" = \")\n for line in range(n*n):\n if (A[row, line] != 0):\n print(A[row, line], \"rho\", getStateLabelsFromLineNo(line, n))" ]

[ [ "numpy.zeros" ] ]

RDLLab/benevolent-deception-gym

[ "4d04e097609097e0f07c661aac221184ebdec2fe" ]

[ "bdgym/envs/driver_assistant/policy.py" ]

[ "\"\"\"Driver Policies for the Driver Assistant Environment \"\"\"\nfrom copy import deepcopy\nfrom typing import Tuple, Optional, List, Dict\n\nimport numpy as np\n\nfrom highway_env.utils import not_zero, do_every\nfrom highway_env.types import Vector\nfrom highway_env.road.lane import AbstractLane\nfrom highway_env.envs.common.action import Action\nfrom highway_env.vehicle.kinematics import Vehicle\nfrom highway_env.vehicle.behavior import IDMVehicle\nfrom highway_env.road.road import Road, LaneIndex, Route\n\nimport bdgym.envs.utils as utils\nfrom bdgym.envs.driver_assistant.action import AssistantDiscreteAction\nfrom bdgym.envs.driver_assistant.vehicle import DriverAssistantVehicle\nfrom bdgym.envs.driver_assistant.driver_types import \\\n sample_driver_config, DRIVER_PARAM_LIMITS\n\nObservation = np.ndarray\n\n\nclass IDMDriverPolicy(IDMVehicle):\n \"\"\"A driver Policy that acts similar to IDMVehicle.\n\n Key difference is that it's decisions are based on the observations\n of it's own position and velocity that it recieves from the assistant and\n the noisy observations it recieves about the other nearby vehicles\n \"\"\"\n\n MAX_SPEED = DriverAssistantVehicle.MAX_SPEED\n\n def __init__(self,\n road: Road,\n position: Vector,\n heading: float = 0,\n speed: float = 0,\n target_lane_index: int = None,\n target_speed: float = None,\n route: Route = None,\n enable_lane_change: bool = True,\n timer: float = None,\n acc_max: float = None,\n comfort_acc_max: float = None,\n comfort_acc_min: float = None,\n distance_wanted: float = None,\n time_wanted: float = None,\n delta: float = None,\n politeness: float = None,\n lane_change_min_acc_gain: float = None,\n lane_change_max_braking_imposed: float = None,\n lane_change_delay: float = None,\n **kwargs):\n super().__init__(\n road,\n position,\n heading=heading,\n speed=speed,\n target_lane_index=target_lane_index,\n target_speed=target_speed,\n route=route,\n enable_lane_change=enable_lane_change,\n timer=timer\n )\n\n self.acc_max = self.ACC_MAX if acc_max is None else acc_max\n self.comfort_acc_max = self.COMFORT_ACC_MAX \\\n if comfort_acc_max is None else comfort_acc_max\n self.comfort_acc_min = self.COMFORT_ACC_MIN \\\n if comfort_acc_min is None else comfort_acc_min\n self.distance_wanted = self.DISTANCE_WANTED \\\n if distance_wanted is None else distance_wanted\n self.time_wanted = self.TIME_WANTED \\\n if time_wanted is None else time_wanted\n self.delta = self.DELTA if delta is None else delta\n self.politeness = self.POLITENESS if politeness is None else politeness\n self.lane_change_min_acc_gain = self.LANE_CHANGE_MIN_ACC_GAIN \\\n if lane_change_min_acc_gain is None else lane_change_min_acc_gain\n self.lane_change_max_braking_imposed = \\\n self.LANE_CHANGE_MAX_BRAKING_IMPOSED \\\n if lane_change_max_braking_imposed is None \\\n else lane_change_max_braking_imposed\n self.lane_change_delay = self.LANE_CHANGE_DELAY \\\n if lane_change_delay is None else lane_change_delay\n\n if timer is None:\n self.timer = (np.sum(self.position)*np.pi) % self.lane_change_delay\n\n @classmethod\n def create_from(cls, vehicle: Vehicle, **kwargs) -> \"IDMDriverPolicy\":\n \"\"\"\n Create a new vehicle from an existing one.\n\n The vehicle dynamics are copied, other properties are default.\n\n :param vehicle: a vehicle\n :return: a new vehicle at the same dynamical state\n \"\"\"\n return cls(\n road=vehicle.road,\n position=vehicle.position,\n heading=vehicle.heading,\n speed=vehicle.speed,\n **kwargs\n )\n\n def get_action(self, obs: np.ndarray, dt: float) -> Action:\n \"\"\"\n Get the next action driver will take\n\n Note: assistant signal and other vehicle observations should\n be non-normalized values.\n\n :param obs: the driver observation of ego and neighbouring vehicles\n ['presence', 'x', 'y', 'vx', 'vy', 'acceleration', 'steering']\n :param dt: the step size for action\n :return: action ['acceleration', 'steering'] the vehicle would take\n \"\"\"\n assistant_signal, other_vehicle_obs = self.parse_obs(obs)\n self._update_dynamics(assistant_signal, dt)\n return self._get_idm_action(other_vehicle_obs)\n\n @staticmethod\n def parse_obs(obs: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:\n \"\"\"Parse driver observation into ego and other vehicle obs \"\"\"\n # for ego vehicle ignore 'presence' feature\n assistant_signal = obs[0][1:]\n # for other vehicle obs ignore 'acceleration' and 'steering' as these\n # are always 0.0 for other vehicles\n other_vehicle_obs = obs[1:, :-2]\n return assistant_signal, other_vehicle_obs\n\n def _update_dynamics(self, ego_vehicle_obs: Action, dt: float):\n self.position = ego_vehicle_obs[0:2]\n vx, vy = ego_vehicle_obs[2], ego_vehicle_obs[3]\n self.speed, self.heading = self._get_speed_and_heading(vx, vy)\n if self.road:\n self.lane_index = self.road.network.get_closest_lane_index(\n self.position\n )\n self.lane = self.road.network.get_lane(self.lane_index)\n # self.road.update_nearest_neighbours()\n\n self.timer += dt\n\n @staticmethod\n def _get_speed_and_heading(vx: float, vy: float) -> Tuple[float, float]:\n speed = np.sqrt(vx**2 + vy**2)\n if speed == 0.0:\n # vx = vy = 0.0\n heading = 0.0\n elif vx == 0.0:\n heading = np.arcsin(vy / speed)\n elif vy == 0.0:\n heading = np.arccos(vx / speed)\n else:\n heading = np.arctan(vy / vx)\n return speed, heading\n\n @staticmethod\n def _get_direction(heading: float) -> np.ndarray:\n return np.array([np.cos(heading), np.sin(heading)])\n\n @property\n def observation(self) -> np.ndarray:\n \"\"\"Vehicle position and velocity in standard observation format \"\"\"\n return np.array([1.0, *self.position, *self.velocity])\n\n @property\n def configuration(self) -> dict:\n \"\"\"The driver policy parameters \"\"\"\n config = {\n param: self.__getattribute__(param)\n for param in DRIVER_PARAM_LIMITS\n }\n return config\n\n def _get_idm_action(self, other_vehicle_obs: np.ndarray) -> np.ndarray:\n # Lateral: MOBIL\n self.follow_road()\n if self.enable_lane_change:\n self._change_lane_policy(other_vehicle_obs)\n steering = self.steering_control(self.target_lane_index)\n steering = np.clip(\n steering, -self.MAX_STEERING_ANGLE, self.MAX_STEERING_ANGLE\n )\n\n # Longitudinal: IDM\n front_vehicle_obs, _ = self._get_neighbours(other_vehicle_obs)\n acceleration = self._acceleration_from_obs(front_vehicle_obs)\n acceleration = np.clip(acceleration, -1*self.acc_max, self.acc_max)\n return np.array([acceleration, steering])\n\n def _acceleration_from_obs(self, front_vehicle_obs: np.ndarray) -> float:\n acceleration = self.comfort_acc_max * (\n 1 - np.power(max(self.speed, 0) / self.target_speed, self.delta)\n )\n\n if front_vehicle_obs is not None:\n front_pos = front_vehicle_obs[1:3]\n d = (\n self.lane.local_coordinates(front_pos)[0]\n - self.lane.local_coordinates(self.position)[0]\n )\n gap = self._desired_gap_from_obs(front_vehicle_obs)\n gap /= not_zero(d)\n acceleration -= self.comfort_acc_max * np.power(gap, 2)\n\n return acceleration\n\n def _acceleration(self,\n ego_xy: Tuple[float, float],\n ego_velocity: Tuple[float, float],\n front_xy: Tuple[float, float] = None,\n front_velocity: Tuple[float, float] = None,\n lane: AbstractLane = None) -> float:\n ego_target_speed = not_zero(0)\n ego_speed, ego_heading = self._get_speed_and_heading(*ego_velocity)\n speed = max(ego_speed, 0) / ego_target_speed\n\n acceleration = self.comfort_acc_max * (\n 1 - np.power(speed, self.delta)\n )\n\n if front_xy is not None:\n if lane is None:\n lane = self.lane\n\n d = (\n lane.local_coordinates(front_xy)[0]\n - lane.local_coordinates(ego_xy)[0]\n )\n ego_direction = self._get_direction(ego_heading)\n gap = self._desired_gap(\n ego_velocity, ego_speed, ego_direction, front_velocity\n )\n gap /= not_zero(d)\n acceleration -= self.comfort_acc_max * np.power(gap, 2)\n return acceleration\n\n def _desired_gap_from_obs(self, vehicle_obs: np.ndarray):\n other_velocity = vehicle_obs[3:4]\n return self._desired_gap(\n self.velocity, self.speed, self.direction, other_velocity\n )\n\n def _desired_gap(self,\n ego_velocity: np.ndarray,\n ego_speed: float,\n ego_direction: float,\n other_velocity: np.ndarray) -> float:\n d0 = self.distance_wanted\n tau = self.time_wanted\n ab = -1*self.comfort_acc_max * self.comfort_acc_min\n dv = np.dot(ego_velocity - other_velocity, ego_direction)\n d_star = d0 + ego_speed * tau + ego_speed * dv / (2 * np.sqrt(ab))\n return d_star\n\n def _get_neighbours(self,\n other_vehicle_obs: np.ndarray,\n lane_index: LaneIndex = None\n ) -> Tuple[Optional[Vehicle], Optional[Vehicle]]:\n \"\"\"Get closest vehicles to ego vehicle within specified lane \"\"\"\n if lane_index is None:\n lane_index = self.lane_index\n\n lane = self.road.network.get_lane(lane_index)\n ego_lane_x = lane.local_coordinates(self.position)[0]\n\n closest_front = None\n min_front_distance = float('inf')\n closest_rear = None\n min_rear_distance = float('inf')\n\n for other in other_vehicle_obs:\n other_xy = other[1:3]\n if not lane.on_lane(other_xy):\n continue\n\n other_lane_x = lane.local_coordinates(other_xy)[0]\n distance = abs(other_lane_x - ego_lane_x)\n if ego_lane_x < other_lane_x and distance < min_front_distance:\n closest_front = other\n min_front_distance = distance\n elif ego_lane_x > other_lane_x and distance < min_rear_distance:\n closest_rear = other\n min_rear_distance = distance\n\n return closest_front, closest_rear\n\n def _change_lane_policy(self, other_vehicle_obs: np.ndarray) -> None:\n # at a given frequency,\n if not do_every(self.lane_change_delay, self.timer):\n return\n self.timer = 0\n\n # decide to make a lane change\n for lane_index in self.road.network.side_lanes(self.lane_index):\n # Is the candidate lane close enough?\n if not self.road.network.get_lane(lane_index).is_reachable_from(\n self.position):\n continue\n # Does the MOBIL model recommend a lane change?\n if self._mobil(lane_index, other_vehicle_obs):\n self.target_lane_index = lane_index\n\n def _mobil(self,\n lane_index: LaneIndex,\n other_vehicle_obs: np.ndarray) -> bool:\n \"\"\" Overrides parent \"\"\"\n # Is the maneuver unsafe for the new following vehicle?\n new_preceding, new_following = self._get_neighbours(\n other_vehicle_obs, lane_index\n )\n\n lane = self.road.network.get_lane(lane_index)\n ego_obs = self.observation\n\n new_following_a, new_following_pred_a = self._acceleration_changes(\n following=new_following,\n preceding=new_preceding,\n new_preceding=ego_obs,\n lane=lane\n )\n if new_following_pred_a < -1*self.lane_change_max_braking_imposed:\n return False\n\n # Do I have a planned route for a specific lane which is safe for me\n # to access?\n old_preceding, old_following = self._get_neighbours(other_vehicle_obs)\n self_pred_a = self._acceleration_from_obs(new_preceding)\n\n if self.route and self.route[0][2]:\n # Wrong direction\n if np.sign(lane_index[2] - self.target_lane_index[2]) \\\n != np.sign(self.route[0][2] - self.target_lane_index[2]):\n return False\n # Unsafe braking required\n if self_pred_a < -1*self.lane_change_max_braking_imposed:\n return False\n else:\n # Is there an acceleration advantage for me and/or my\n # followers to change lane?\n self_a = self._acceleration_from_obs(old_preceding)\n\n old_following_a, old_following_pred_a = self._acceleration_changes(\n following=old_following,\n preceding=ego_obs,\n new_preceding=old_preceding\n )\n\n jerk = self_pred_a - self_a\n jerk += self.politeness * (\n new_following_pred_a - new_following_a\n + old_following_pred_a - old_following_a\n )\n if jerk < self.lane_change_min_acc_gain:\n return False\n\n # All clear, let's go!\n return True\n\n def _acceleration_changes(self,\n following: np.ndarray,\n preceding: np.ndarray,\n new_preceding: np.ndarray,\n lane: AbstractLane = None\n ) -> Tuple[float, float]:\n following_a = 0.0\n following_pred_a = 0.0\n if following is not None and preceding is not None:\n following_a = self._acceleration(\n ego_xy=following[1:3],\n ego_velocity=following[3:5],\n front_xy=preceding[1:3],\n front_velocity=preceding[3:5],\n lane=lane\n )\n\n if following is not None and new_preceding is not None:\n following_pred_a = self._acceleration(\n ego_xy=following[1:3],\n ego_velocity=following[3:5],\n front_xy=new_preceding[1:3],\n front_velocity=new_preceding[3:5],\n lane=lane\n )\n return following_a, following_pred_a\n\n\nclass IDMAssistantPolicy(IDMDriverPolicy):\n \"\"\"An IDM Assistant policy that provides vehicle obs and recommendation\n\n Specifically:\n - Returns the actual observations recieved for the driver vehicle\n - Recommends acceleration and steering controls to the driver based on IDM\n model\n \"\"\"\n\n def __init__(self,\n road: Road,\n position: Vector,\n *args,\n action_ranges: Optional[Dict[str, List[float]]] = None,\n normalize: bool = True,\n **kwargs):\n super().__init__(road, position, *args, **kwargs)\n self.action_ranges = {}\n if action_ranges is not None:\n self.action_ranges = action_ranges\n self.normalize = normalize\n\n def get_action(self, obs: np.ndarray, dt: float) -> Action:\n \"\"\"\n Get the next action assistant will take\n\n :param full_obs: full observation of vehicle including of nearby\n vehicles. Includes ['presence', 'x', 'y', 'vx', 'vy']\n :return: the assistant action\n ['x', 'y', 'vx', 'vy', 'acceleration', 'steering']\n \"\"\"\n other_vehicle_obs = obs[1:, :]\n assistant_signal = obs[0, 1:]\n self._update_dynamics(assistant_signal, dt)\n recommended_controls = self._get_idm_action(other_vehicle_obs)\n\n action = np.concatenate((assistant_signal, recommended_controls))\n\n if self.normalize:\n for i, frange in enumerate(self.action_ranges.values()):\n action[i] = utils.lmap(\n action[i], frange, [-1, 1]\n )\n\n return action\n\n\nclass RandomAssistantPolicy(IDMAssistantPolicy):\n \"\"\"A Random Assistant policy\n\n Specifically:\n - Returns the actual observations recieved for the driver vehicle\n - Recommends a random acceleration and steering control to the driver\n \"\"\"\n\n def get_action(self, obs: np.ndarray, dt: float) -> Action:\n \"\"\" Overrides IDMDriverVehicle.get_action() \"\"\"\n action = super().get_action(obs, dt)\n action[4] = utils.get_truncated_normal(0.0, 1.0, -1.0, 1.0)\n action[5] = utils.get_truncated_normal(0.0, 1.0, -1.0, 1.0)\n return action\n\n\nclass RandomDiscreteAssistantPolicy(IDMAssistantPolicy):\n \"\"\"A Random Assistant policy for Discrete Assistant Action\n\n Specifically:\n - Returns the actual observations recieved for the driver vehicle\n - Recommends a random acceleration and steering control to the driver\n \"\"\"\n\n def get_action(self, obs: np.ndarray, dt: float) -> Action:\n \"\"\" Overrides IDMDriverVehicle.get_action() \"\"\"\n avail_actions = [\n AssistantDiscreteAction.NOOP,\n AssistantDiscreteAction.UP,\n AssistantDiscreteAction.DOWN\n ]\n action = np.full(\n AssistantDiscreteAction.ASSISTANT_DISCRETE_ACTION_SPACE_SIZE,\n AssistantDiscreteAction.NOOP\n )\n action[4] = np.random.choice(avail_actions)\n action[5] = np.random.choice(avail_actions)\n return action\n\n\nclass DoNothingDiscreteAssistantPolicy(IDMAssistantPolicy):\n \"\"\"Assistant policy that recommends no action and applies no deception \"\"\"\n\n def get_action(self, obs: np.ndarray, dt: float) -> Action:\n \"\"\" Overrides IDMDriverVehicle.get_action() \"\"\"\n action = np.full(\n AssistantDiscreteAction.ASSISTANT_DISCRETE_ACTION_SPACE_SIZE,\n AssistantDiscreteAction.NOOP\n )\n return action\n\n\nclass RandomDriverPolicy(IDMDriverPolicy):\n \"\"\"A Random driver policy \"\"\"\n\n def get_action(self, obs: np.ndarray, dt: float) -> Action:\n \"\"\" Overrides IDMDriverVehicle.get_action() \"\"\"\n assistant_signal, _ = self.parse_obs(obs)\n self._update_dynamics(assistant_signal, dt)\n return np.random.uniform(\n low=[-1*self.acc_max, -1*self.MAX_STEERING_ANGLE],\n high=[self.acc_max, self.MAX_STEERING_ANGLE],\n )\n\n\nclass GuidedIDMDriverPolicy(IDMDriverPolicy):\n \"\"\"A Driver policy that also considers recommended actions from assistant\n\n How much the driver follows the assistant's suggestions versus relying on\n the IDM driver model is controlled by the \"independence\" hyperparameter\n \"\"\"\n\n def __init__(self,\n road: Road,\n position: Vector,\n *args,\n independence: float = 0.9,\n **kwargs):\n super().__init__(road, position, *args, **kwargs)\n self.independence = independence\n\n @property\n def configuration(self) -> dict:\n \"\"\"The driver policy parameters \"\"\"\n config = super().configuration\n config[\"independence\"] = self.independence\n return config\n\n def get_action(self, obs: np.ndarray, dt: float) -> Action:\n \"\"\" Overrides IDMDriverVehicle.get_action() \"\"\"\n assistant_signal, other_vehicle_obs = self.parse_obs(obs)\n self._update_dynamics(assistant_signal, dt)\n idm_action = self._get_idm_action(other_vehicle_obs)\n action = self._calc_action(assistant_signal[-2:], idm_action)\n return action\n\n def _calc_action(self,\n assistant_action: np.ndarray,\n idm_action: np.ndarray) -> np.ndarray:\n return (\n (1 - self.independence) * assistant_action\n + (self.independence * idm_action)\n )\n\n\nclass ChangingGuidedIDMDriverPolicy(GuidedIDMDriverPolicy):\n \"\"\"A GuidedIDMDriverPolicy where the driver parameters can be re-sampled\n\n How much the driver follows the assistant's suggestions versus relying on\n the IDM driver model is controlled by the \"independence\" hyperparameter\n \"\"\"\n\n INDEPENDENCE_DIST = utils.get_truncated_normal(\n 0.5, 0.25, 0.0, 1.0\n )\n\n def __init__(self,\n road: Road,\n position: Vector,\n *args,\n independence: float = 0.9,\n **kwargs):\n super().__init__(road, position, *args, **kwargs)\n self.independence = independence\n\n def get_action(self, obs: np.ndarray, dt: float) -> Action:\n \"\"\" Overrides IDMDriverVehicle.get_action() \"\"\"\n assistant_signal, other_vehicle_obs = self.parse_obs(obs)\n self._update_dynamics(assistant_signal, dt)\n idm_action = self._get_idm_action(other_vehicle_obs)\n action = self._calc_action(assistant_signal[-2:], idm_action)\n return action\n\n def _calc_action(self,\n assistant_action: np.ndarray,\n idm_action: np.ndarray) -> np.ndarray:\n return (\n (1 - self.independence) * assistant_action\n + (self.independence * idm_action)\n )\n\n @classmethod\n def create_from(cls, vehicle: Vehicle, **kwargs) -> \"IDMDriverPolicy\":\n \"\"\"\n Create a new vehicle from an existing one.\n\n The vehicle dynamics are copied, other properties are default.\n\n :param vehicle: a vehicle\n :return: a new vehicle at the same dynamical state\n \"\"\"\n driver_config = deepcopy(kwargs)\n driver_config.update(sample_driver_config())\n\n if kwargs.get(\"force_independent\", False):\n driver_config[\"independence\"] = 1.0\n else:\n driver_config[\"independence\"] = cls.INDEPENDENCE_DIST.rvs()\n\n return cls(\n road=vehicle.road,\n position=vehicle.position,\n heading=vehicle.heading,\n speed=vehicle.speed,\n **kwargs\n )\n\n\ndef driver_policy_factory(env, driver_config: dict) -> 'IDMDriverPolicy':\n \"\"\"Get the driver policy for given driver configuration \"\"\"\n if driver_config[\"type\"] == \"RandomDriverPolicy\":\n policy_cls = RandomDriverPolicy\n elif driver_config[\"type\"] == \"GuidedIDMDriverPolicy\":\n policy_cls = GuidedIDMDriverPolicy\n elif driver_config[\"type\"] == \"ChangingGuidedIDMDriverPolicy\":\n policy_cls = ChangingGuidedIDMDriverPolicy\n else:\n raise ValueError(f\"Unsupported Driver Type: {driver_config['type']}\")\n\n return policy_cls.create_from(env.vehicle, **driver_config)\n" ]

[ [ "numpy.dot", "numpy.sqrt", "numpy.arctan", "numpy.clip", "numpy.random.choice", "numpy.arcsin", "numpy.power", "numpy.cos", "numpy.arccos", "numpy.full", "numpy.concatenate", "numpy.sin", "numpy.sign", "numpy.random.uniform", "numpy.array", "numpy.sum" ] ]

chaseaucoin/Neural-Primer

[ "d5163af8cd74ea5cea620069dffca8c124bffc05" ]

[ "Numpy XOR/Tensor_ImageRecognition.py" ]

[ "from tensorflow.examples.tutorials.mnist import input_data\r\n\r\n#Get The MNIST Data\r\nmnist = input_data.read_data_sets(\"MNIST_data/\", one_hot=True)\r\n\r\nimport tensorflow as tf\r\n\r\n# Create the model\r\ninputs = tf.placeholder(tf.float32, [None, 784])\r\nweights = tf.Variable(tf.zeros([784, 10]))\r\nbiases = tf.Variable(tf.zeros([10]))\r\npredictions = tf.matmul(inputs, weights) + biases\r\n\r\n# Define loss and optimizer\r\nexpectedPredictions = tf.placeholder(tf.float32, [None, 10])\r\n\r\n# The raw formulation of cross-entropy,\r\n#\r\n# tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(tf.nn.softmax(y)),\r\n# reduction_indices=[1]))\r\n#\r\n# can be numerically unstable.\r\n#\r\n# So here we use tf.nn.softmax_cross_entropy_with_logits on the raw\r\n# outputs of 'y', and then average across the batch.\r\n\r\nmeanError = tf.reduce_mean(\r\n tf.nn.softmax_cross_entropy_with_logits(labels=expectedPredictions, logits=predictions))\r\n\r\ntrain_step = tf.train.GradientDescentOptimizer(0.1).minimize(meanError)\r\n\r\nsess = tf.InteractiveSession()\r\ntf.global_variables_initializer().run()\r\n# Train\r\nfor _ in range(1000):\r\n batch_xs, batch_ys = mnist.train.next_batch(100)\r\n sess.run(train_step, feed_dict={inputs: batch_xs, expectedPredictions: batch_ys})\r\n\r\n # Test trained model\r\n correct_prediction = tf.equal(tf.argmax(predictions, 1), tf.argmax(expectedPredictions, 1))\r\n accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\r\n print(sess.run(accuracy, feed_dict={inputs: mnist.test.images,\r\n expectedPredictions: mnist.test.labels}))" ]

[ [ "tensorflow.matmul", "tensorflow.nn.softmax_cross_entropy_with_logits", "tensorflow.InteractiveSession", "tensorflow.zeros", "tensorflow.cast", "tensorflow.placeholder", "tensorflow.global_variables_initializer", "tensorflow.train.GradientDescentOptimizer", "tensorflow.argmax", "tensorflow.examples.tutorials.mnist.input_data.read_data_sets" ] ]

dan0nchik/FLAML

[ "9d661759b49de6e403d9288af7a015606528fe7e" ]

[ "flaml/model.py" ]

[ "'''!\r\n * Copyright (c) 2020-2021 Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License. \r\n'''\r\n\r\nimport numpy as np\r\nimport xgboost as xgb\r\nimport time\r\nfrom sklearn.ensemble import RandomForestRegressor, RandomForestClassifier\r\nfrom sklearn.ensemble import ExtraTreesRegressor, ExtraTreesClassifier\r\nfrom sklearn.linear_model import LogisticRegression\r\nfrom lightgbm import LGBMClassifier, LGBMRegressor\r\nfrom scipy.sparse import issparse\r\nimport pandas as pd\r\nfrom . import tune\r\n\r\nimport logging\r\nlogger = logging.getLogger(__name__)\r\n\r\n\r\nclass BaseEstimator:\r\n '''The abstract class for all learners\r\n\r\n Typical example:\r\n XGBoostEstimator: for regression\r\n XGBoostSklearnEstimator: for classification\r\n LGBMEstimator, RandomForestEstimator, LRL1Classifier, LRL2Classifier: \r\n for both regression and classification \r\n '''\r\n\r\n def __init__(self, task = 'binary:logistic', **params):\r\n '''Constructor\r\n \r\n Args:\r\n task: A string of the task type, one of\r\n 'binary:logistic', 'multi:softmax', 'regression'\r\n n_jobs: An integer of the number of parallel threads\r\n params: A dictionary of the hyperparameter names and values\r\n '''\r\n self.params = params\r\n self.estimator_class = self._model = None\r\n self._task = task\r\n if '_estimator_type' in params:\r\n self._estimator_type = params['_estimator_type']\r\n else:\r\n self._estimator_type = \"regressor\" if task=='regression' \\\r\n else \"classifier\" \r\n\r\n def get_params(self, deep=False):\r\n params = self.params.copy()\r\n params[\"task\"] = self._task\r\n if hasattr(self, '_estimator_type'):\r\n params['_estimator_type'] = self._estimator_type\r\n return params\r\n\r\n @property\r\n def classes_(self):\r\n return self._model.classes_\r\n\r\n @property\r\n def n_features_in_(self): \r\n return self.model.n_features_in_\r\n\r\n @property\r\n def model(self):\r\n '''Trained model after fit() is called, or None before fit() is called\r\n '''\r\n return self._model\r\n\r\n def _preprocess(self, X):\r\n return X\r\n\r\n def _fit(self, X_train, y_train, **kwargs): \r\n\r\n curent_time = time.time()\r\n X_train = self._preprocess(X_train)\r\n model = self.estimator_class(**self.params)\r\n model.fit(X_train, y_train, **kwargs)\r\n train_time = time.time() - curent_time\r\n self._model = model\r\n return train_time\r\n\r\n def fit(self, X_train, y_train, budget=None, **kwargs):\r\n '''Train the model from given training data\r\n \r\n Args:\r\n X_train: A numpy array of training data in shape n*m\r\n y_train: A numpy array of labels in shape n*1\r\n budget: A float of the time budget in seconds\r\n\r\n Returns:\r\n train_time: A float of the training time in seconds\r\n '''\r\n return self._fit(X_train, y_train, **kwargs)\r\n\r\n def predict(self, X_test):\r\n '''Predict label from features\r\n \r\n Args:\r\n X_test: A numpy array of featurized instances, shape n*m\r\n\r\n Returns:\r\n A numpy array of shape n*1. \r\n Each element is the label for a instance\r\n ''' \r\n X_test = self._preprocess(X_test)\r\n return self._model.predict(X_test)\r\n\r\n def predict_proba(self, X_test):\r\n '''Predict the probability of each class from features\r\n\r\n Only works for classification problems\r\n\r\n Args:\r\n model: An object of trained model with method predict_proba()\r\n X_test: A numpy array of featurized instances, shape n*m\r\n\r\n Returns:\r\n A numpy array of shape n*c. c is the # classes\r\n Each element at (i,j) is the probability for instance i to be in\r\n class j\r\n '''\r\n if 'regression' in self._task:\r\n print('Regression tasks do not support predict_prob')\r\n raise ValueError\r\n else:\r\n X_test = self._preprocess(X_test)\r\n return self._model.predict_proba(X_test)\r\n\r\n def cleanup(self): pass\r\n\r\n @classmethod\r\n def search_space(cls, **params): \r\n '''[required method] search space\r\n\r\n Returns:\r\n A dictionary of the search space. \r\n Each key is the name of a hyperparameter, and value is a dict with\r\n its domain and init_value (optional), cat_hp_cost (optional) \r\n e.g., \r\n {'domain': tune.randint(lower=1, upper=10), 'init_value': 1}\r\n '''\r\n return {}\r\n\r\n @classmethod\r\n def size(cls, config): \r\n '''[optional method] memory size of the estimator in bytes\r\n \r\n Args:\r\n config - the dict of the hyperparameter config\r\n\r\n Returns:\r\n A float of the memory size required by the estimator to train the\r\n given config\r\n '''\r\n return 1.0\r\n\r\n @classmethod\r\n def cost_relative2lgbm(cls):\r\n '''[optional method] relative cost compared to lightgbm'''\r\n return 1.0\r\n\r\n\r\nclass SKLearnEstimator(BaseEstimator):\r\n\r\n\r\n def _preprocess(self, X):\r\n if isinstance(X, pd.DataFrame):\r\n X = X.copy()\r\n cat_columns = X.select_dtypes(include=['category']).columns\r\n X[cat_columns] = X[cat_columns].apply(lambda x: x.cat.codes)\r\n return X\r\n\r\n\r\nclass LGBMEstimator(BaseEstimator):\r\n\r\n\r\n @classmethod\r\n def search_space(cls, data_size, **params): \r\n upper = min(32768,int(data_size))\r\n return {\r\n 'n_estimators': {\r\n 'domain': tune.qloguniform(lower=4, upper=upper, q=1),\r\n 'init_value': 4,\r\n },\r\n 'max_leaves': {\r\n 'domain': tune.qloguniform(lower=4, upper=upper, q=1),\r\n 'init_value': 4,\r\n },\r\n 'min_child_weight': {\r\n 'domain': tune.loguniform(lower=0.001, upper=20.0),\r\n 'init_value': 20.0,\r\n },\r\n 'learning_rate': {\r\n 'domain': tune.loguniform(lower=0.01, upper=1.0),\r\n 'init_value': 0.1,\r\n },\r\n 'subsample': {\r\n 'domain': tune.uniform(lower=0.6, upper=1.0),\r\n 'init_value': 1.0,\r\n }, \r\n 'log_max_bin': {\r\n 'domain': tune.qloguniform(lower=3, upper=10, q=1),\r\n 'init_value': 8,\r\n }, \r\n 'colsample_bytree': {\r\n 'domain': tune.uniform(lower=0.7, upper=1.0),\r\n 'init_value': 1.0,\r\n }, \r\n 'reg_alpha': {\r\n 'domain': tune.loguniform(lower=1e-10, upper=1.0),\r\n 'init_value': 1e-10,\r\n }, \r\n 'reg_lambda': {\r\n 'domain': tune.loguniform(lower=1e-10, upper=1.0),\r\n 'init_value': 1.0,\r\n }, \r\n }\r\n\r\n @classmethod\r\n def size(cls, config):\r\n max_leaves = int(round(config['max_leaves']))\r\n n_estimators = int(round(config['n_estimators']))\r\n return (max_leaves*3 + (max_leaves-1)*4 + 1.0)*n_estimators*8\r\n\r\n def __init__(self, task='binary:logistic', n_jobs=1,\r\n n_estimators=2, max_leaves=2, min_child_weight=1e-3, learning_rate=0.1, \r\n subsample=1.0, reg_lambda=1.0, reg_alpha=0.0, colsample_bylevel=1.0, \r\n colsample_bytree=1.0, log_max_bin=8, **params):\r\n super().__init__(task, **params)\r\n # Default: ‘regression’ for LGBMRegressor, \r\n # ‘binary’ or ‘multiclass’ for LGBMClassifier\r\n if 'regression' in task:\r\n objective = 'regression'\r\n elif 'binary' in task:\r\n objective = 'binary'\r\n elif 'multi' in task:\r\n objective = 'multiclass'\r\n else: objective = 'regression'\r\n self.params = {\r\n \"n_estimators\": int(round(n_estimators)),\r\n \"num_leaves\": params[\r\n 'num_leaves'] if 'num_leaves' in params else int(\r\n round(max_leaves)),\r\n 'objective': params[\r\n \"objective\"] if \"objective\" in params else objective,\r\n 'n_jobs': n_jobs,\r\n 'learning_rate': float(learning_rate),\r\n 'reg_alpha': float(reg_alpha),\r\n 'reg_lambda': float(reg_lambda),\r\n 'min_child_weight': float(min_child_weight),\r\n 'colsample_bytree':float(colsample_bytree),\r\n 'subsample': float(subsample),\r\n }\r\n self.params['max_bin'] = params['max_bin'] if 'max_bin' in params else (\r\n 1<<int(round(log_max_bin)))-1\r\n if 'regression' in task:\r\n self.estimator_class = LGBMRegressor\r\n else:\r\n self.estimator_class = LGBMClassifier\r\n self._time_per_iter = None\r\n self._train_size = 0\r\n\r\n def _preprocess(self, X):\r\n if not isinstance(X, pd.DataFrame) and issparse(\r\n X) and np.issubdtype(X.dtype, np.integer):\r\n X = X.astype(float)\r\n return X\r\n\r\n def fit(self, X_train, y_train, budget=None, **kwargs):\r\n start_time = time.time()\r\n n_iter = self.params[\"n_estimators\"]\r\n if (not self._time_per_iter or\r\n abs(self._train_size-X_train.shape[0])>4) and budget is not None:\r\n self.params[\"n_estimators\"] = 1\r\n self._t1 = self._fit(X_train, y_train, **kwargs)\r\n if self._t1 >= budget: \r\n self.params[\"n_estimators\"] = n_iter\r\n return self._t1\r\n self.params[\"n_estimators\"] = 4\r\n self._t2 = self._fit(X_train, y_train, **kwargs)\r\n self._time_per_iter = (self._t2 - self._t1)/(\r\n self.params[\"n_estimators\"]-1) if self._t2 > self._t1 \\\r\n else self._t1 if self._t1 else 0.001\r\n self._train_size = X_train.shape[0]\r\n if self._t1+self._t2>=budget or n_iter==self.params[\"n_estimators\"]:\r\n self.params[\"n_estimators\"] = n_iter\r\n return time.time() - start_time\r\n if budget is not None:\r\n self.params[\"n_estimators\"] = min(n_iter, int((budget-time.time()+\r\n start_time-self._t1)/self._time_per_iter+1))\r\n if self.params[\"n_estimators\"] > 0:\r\n self._fit(X_train, y_train, **kwargs)\r\n self.params[\"n_estimators\"] = n_iter\r\n train_time = time.time() - start_time\r\n return train_time\r\n\r\n\r\nclass XGBoostEstimator(SKLearnEstimator):\r\n ''' not using sklearn API, used for regression '''\r\n\r\n\r\n @classmethod\r\n def search_space(cls, data_size, **params): \r\n upper = min(32768,int(data_size))\r\n return {\r\n 'n_estimators': {\r\n 'domain': tune.qloguniform(lower=4, upper=upper, q=1),\r\n 'init_value': 4,\r\n },\r\n 'max_leaves': {\r\n 'domain': tune.qloguniform(lower=4, upper=upper, q=1),\r\n 'init_value': 4,\r\n },\r\n 'min_child_weight': {\r\n 'domain': tune.loguniform(lower=0.001, upper=20.0),\r\n 'init_value': 20.0,\r\n },\r\n 'learning_rate': {\r\n 'domain': tune.loguniform(lower=0.01, upper=1.0),\r\n 'init_value': 0.1,\r\n },\r\n 'subsample': {\r\n 'domain': tune.uniform(lower=0.6, upper=1.0),\r\n 'init_value': 1.0,\r\n }, \r\n 'colsample_bylevel': {\r\n 'domain': tune.uniform(lower=0.6, upper=1.0),\r\n 'init_value': 1.0,\r\n }, \r\n 'colsample_bytree': {\r\n 'domain': tune.uniform(lower=0.7, upper=1.0),\r\n 'init_value': 1.0,\r\n }, \r\n 'reg_alpha': {\r\n 'domain': tune.loguniform(lower=1e-10, upper=1.0),\r\n 'init_value': 1e-10,\r\n }, \r\n 'reg_lambda': {\r\n 'domain': tune.loguniform(lower=1e-10, upper=1.0),\r\n 'init_value': 1.0,\r\n }, \r\n }\r\n \r\n @classmethod\r\n def size(cls, config):\r\n return LGBMEstimator.size(config)\r\n\r\n @classmethod\r\n def cost_relative2lgbm(cls):\r\n return 1.6\r\n\r\n def __init__(self, task='regression', all_thread=False, n_jobs=1,\r\n n_estimators=4, max_leaves=4, subsample=1.0, min_child_weight=1, \r\n learning_rate=0.1, reg_lambda=1.0, reg_alpha=0.0, colsample_bylevel=1.0,\r\n colsample_bytree=1.0, tree_method='auto', **params):\r\n super().__init__(task, **params)\r\n self._n_estimators = int(round(n_estimators))\r\n self._max_leaves = int(round(max_leaves))\r\n self.params = {\r\n 'max_leaves': int(round(max_leaves)),\r\n 'max_depth': 0,\r\n 'grow_policy': params[\r\n \"grow_policy\"] if \"grow_policy\" in params else 'lossguide',\r\n 'tree_method':tree_method,\r\n 'verbosity': 0,\r\n 'nthread':n_jobs,\r\n 'learning_rate': float(learning_rate),\r\n 'subsample': float(subsample),\r\n 'reg_alpha': float(reg_alpha),\r\n 'reg_lambda': float(reg_lambda),\r\n 'min_child_weight': float(min_child_weight),\r\n 'booster': params['booster'] if 'booster' in params else 'gbtree',\r\n 'colsample_bylevel': float(colsample_bylevel),\r\n 'colsample_bytree':float(colsample_bytree),\r\n }\r\n if all_thread:\r\n del self.params['nthread']\r\n\r\n def get_params(self, deep=False):\r\n params = super().get_params()\r\n params[\"n_jobs\"] = params['nthread']\r\n return params\r\n\r\n def fit(self, X_train, y_train, budget=None, **kwargs):\r\n start_time = time.time() \r\n if not issparse(X_train):\r\n self.params['tree_method'] = 'hist'\r\n X_train = self._preprocess(X_train)\r\n dtrain = xgb.DMatrix(X_train, label=y_train)\r\n if self._max_leaves>0:\r\n if 'sample_weight' in kwargs:\r\n self._model = xgb.train(self.params, dtrain,\r\n self._n_estimators, weight=kwargs['sample_weight'])\r\n else:\r\n self._model = xgb.train(self.params, dtrain, self._n_estimators)\r\n del dtrain\r\n train_time = time.time() - start_time\r\n return train_time\r\n else:\r\n return None\r\n\r\n def predict(self, X_test):\r\n if not issparse(X_test):\r\n X_test = self._preprocess(X_test)\r\n dtest = xgb.DMatrix(X_test)\r\n return super().predict(dtest)\r\n\r\n\r\nclass XGBoostSklearnEstimator(SKLearnEstimator, LGBMEstimator):\r\n ''' using sklearn API, used for classification '''\r\n\r\n\r\n @classmethod\r\n def search_space(cls, data_size, **params): \r\n return XGBoostEstimator.search_space(data_size)\r\n\r\n @classmethod\r\n def cost_relative2lgbm(cls):\r\n return XGBoostEstimator.cost_relative2lgbm()\r\n\r\n def __init__(self, task='binary:logistic', n_jobs=1, \r\n n_estimators=4, max_leaves=4, subsample=1.0, \r\n min_child_weight=1, learning_rate=0.1, reg_lambda=1.0, reg_alpha=0.0,\r\n colsample_bylevel=1.0, colsample_bytree=1.0, tree_method='hist', \r\n **params):\r\n super().__init__(task, **params)\r\n self.params = {\r\n \"n_estimators\": int(round(n_estimators)),\r\n 'max_leaves': int(round(max_leaves)),\r\n 'max_depth': 0,\r\n 'grow_policy': params[\r\n \"grow_policy\"] if \"grow_policy\" in params else 'lossguide',\r\n 'tree_method':tree_method,\r\n 'verbosity': 0,\r\n 'n_jobs': n_jobs,\r\n 'learning_rate': float(learning_rate),\r\n 'subsample': float(subsample),\r\n 'reg_alpha': float(reg_alpha),\r\n 'reg_lambda': float(reg_lambda),\r\n 'min_child_weight': float(min_child_weight),\r\n 'booster': params['booster'] if 'booster' in params else 'gbtree',\r\n 'colsample_bylevel': float(colsample_bylevel),\r\n 'colsample_bytree': float(colsample_bytree),\r\n }\r\n\r\n if 'regression' in task:\r\n self.estimator_class = xgb.XGBRegressor\r\n else:\r\n self.estimator_class = xgb.XGBClassifier\r\n self._time_per_iter = None\r\n self._train_size = 0\r\n\r\n def fit(self, X_train, y_train, budget=None, **kwargs):\r\n if issparse(X_train):\r\n self.params['tree_method'] = 'auto'\r\n return super().fit(X_train, y_train, budget, **kwargs)\r\n \r\n\r\nclass RandomForestEstimator(SKLearnEstimator, LGBMEstimator):\r\n\r\n\r\n @classmethod\r\n def search_space(cls, data_size, task, **params): \r\n upper = min(2048, int(data_size))\r\n space = {\r\n 'n_estimators': {\r\n 'domain': tune.qloguniform(lower=4, upper=upper, q=1),\r\n 'init_value': 4,\r\n },\r\n 'max_features': {\r\n 'domain': tune.loguniform(lower=0.1, upper=1.0),\r\n 'init_value': 1.0,\r\n },\r\n }\r\n if task != 'regression':\r\n space['criterion'] = {\r\n 'domain': tune.choice(['gini', 'entropy']),\r\n # 'init_value': 'gini',\r\n }\r\n return space\r\n\r\n @classmethod\r\n def size(cls, config):\r\n return 1.0\r\n\r\n @classmethod\r\n def cost_relative2lgbm(cls):\r\n return 2.0\r\n\r\n def __init__(self, task = 'binary:logistic', n_jobs = 1,\r\n n_estimators = 4, max_features = 1.0, criterion = 'gini', **params):\r\n super().__init__(task, **params)\r\n self.params = {\r\n \"n_estimators\": int(round(n_estimators)),\r\n \"n_jobs\": n_jobs,\r\n 'max_features': float(max_features),\r\n }\r\n if 'regression' in task:\r\n self.estimator_class = RandomForestRegressor\r\n else:\r\n self.estimator_class = RandomForestClassifier\r\n self.params['criterion'] = criterion\r\n self._time_per_iter = None\r\n self._train_size = 0\r\n\r\n def get_params(self, deep=False):\r\n params = super().get_params()\r\n params[\"criterion\"] = 1 if params[\"criterion\"]=='gini' else 2\r\n return params\r\n\r\n\r\nclass ExtraTreeEstimator(RandomForestEstimator):\r\n\r\n\r\n @classmethod\r\n def cost_relative2lgbm(cls):\r\n return 1.9\r\n\r\n def __init__(self, task = 'binary:logistic', **params):\r\n super().__init__(task, **params)\r\n if 'regression' in task:\r\n self.estimator_class = ExtraTreesRegressor\r\n else:\r\n self.estimator_class = ExtraTreesClassifier\r\n\r\n\r\nclass LRL1Classifier(SKLearnEstimator):\r\n\r\n\r\n @classmethod\r\n def search_space(cls, **params): \r\n return {\r\n 'C': {\r\n 'domain': tune.loguniform(lower=0.03125, upper=32768.0),\r\n 'init_value': 1.0,\r\n },\r\n }\r\n\r\n @classmethod\r\n def cost_relative2lgbm(cls):\r\n return 160\r\n\r\n def __init__(self, task='binary:logistic', n_jobs=1, tol=0.0001, C=1.0, \r\n **params):\r\n super().__init__(task, **params)\r\n self.params = {\r\n 'penalty': 'l1',\r\n 'tol': float(tol),\r\n 'C': float(C),\r\n 'solver': 'saga',\r\n 'n_jobs': n_jobs,\r\n }\r\n if 'regression' in task:\r\n self.estimator_class = None\r\n print('LR does not support regression task')\r\n raise NotImplementedError\r\n else:\r\n self.estimator_class = LogisticRegression\r\n\r\n\r\nclass LRL2Classifier(SKLearnEstimator):\r\n\r\n\r\n @classmethod\r\n def search_space(cls, **params): \r\n return LRL1Classifier.search_space(**params)\r\n\r\n @classmethod\r\n def cost_relative2lgbm(cls):\r\n return 25\r\n\r\n def __init__(self, task='binary:logistic', n_jobs=1, tol=0.0001, C=1.0, \r\n **params):\r\n super().__init__(task, **params)\r\n self.params = {\r\n 'penalty': 'l2',\r\n 'tol': float(tol),\r\n 'C': float(C),\r\n 'solver': 'lbfgs',\r\n 'n_jobs': n_jobs,\r\n }\r\n if 'regression' in task:\r\n self.estimator_class = None\r\n print('LR does not support regression task')\r\n raise NotImplementedError\r\n else:\r\n self.estimator_class = LogisticRegression\r\n\r\n\r\nclass CatBoostEstimator(BaseEstimator):\r\n\r\n\r\n _time_per_iter = None\r\n _train_size = 0\r\n\r\n @classmethod\r\n def search_space(cls, data_size, **params): \r\n upper = max(min(round(1500000/data_size),150), 11)\r\n return {\r\n 'early_stopping_rounds': {\r\n 'domain': tune.qloguniform(lower=10, upper=upper, q=1),\r\n 'init_value': 10,\r\n },\r\n 'learning_rate': {\r\n 'domain': tune.loguniform(lower=.005, upper=.2),\r\n 'init_value': 0.1,\r\n },\r\n }\r\n\r\n @classmethod\r\n def size(cls, config):\r\n n_estimators = 8192\r\n max_leaves = 64\r\n return (max_leaves*3 + (max_leaves-1)*4 + 1.0)*n_estimators*8\r\n\r\n @classmethod\r\n def cost_relative2lgbm(cls):\r\n return 15\r\n\r\n def __init__(self, task = 'binary:logistic', n_jobs=1,\r\n n_estimators=8192, learning_rate=0.1, early_stopping_rounds=4, **params):\r\n super().__init__(task, **params)\r\n self.params = {\r\n \"early_stopping_rounds\": int(round(early_stopping_rounds)),\r\n \"n_estimators\": n_estimators, \r\n 'learning_rate': learning_rate,\r\n 'thread_count': n_jobs,\r\n 'verbose': False,\r\n 'random_seed': params[\r\n \"random_seed\"] if \"random_seed\" in params else 10242048,\r\n }\r\n if 'regression' in task:\r\n from catboost import CatBoostRegressor\r\n self.estimator_class = CatBoostRegressor\r\n else:\r\n from catboost import CatBoostClassifier\r\n self.estimator_class = CatBoostClassifier\r\n\r\n def get_params(self, deep=False):\r\n params = super().get_params()\r\n params['n_jobs'] = params['thread_count']\r\n return params\r\n\r\n def fit(self, X_train, y_train, budget=None, **kwargs):\r\n start_time = time.time()\r\n n_iter = self.params[\"n_estimators\"]\r\n if isinstance(X_train, pd.DataFrame):\r\n cat_features = list(X_train.select_dtypes(\r\n include='category').columns)\r\n else:\r\n cat_features = []\r\n if (not CatBoostEstimator._time_per_iter or\r\n abs(CatBoostEstimator._train_size-len(y_train))>4) and budget:\r\n # measure the time per iteration\r\n self.params[\"n_estimators\"] = 1\r\n CatBoostEstimator._smallmodel = self.estimator_class(**self.params)\r\n CatBoostEstimator._smallmodel.fit(X_train, y_train,\r\n cat_features=cat_features, **kwargs)\r\n CatBoostEstimator._t1 = time.time() - start_time\r\n if CatBoostEstimator._t1 >= budget: \r\n self.params[\"n_estimators\"] = n_iter\r\n self._model = CatBoostEstimator._smallmodel\r\n return CatBoostEstimator._t1\r\n self.params[\"n_estimators\"] = 4\r\n CatBoostEstimator._smallmodel = self.estimator_class(**self.params)\r\n CatBoostEstimator._smallmodel.fit(X_train, y_train,\r\n cat_features=cat_features, **kwargs)\r\n CatBoostEstimator._time_per_iter = (time.time() - start_time -\r\n CatBoostEstimator._t1)/(self.params[\"n_estimators\"]-1)\r\n if CatBoostEstimator._time_per_iter <= 0: \r\n CatBoostEstimator._time_per_iter = CatBoostEstimator._t1\r\n CatBoostEstimator._train_size = len(y_train)\r\n if time.time()-start_time>=budget or n_iter==self.params[\r\n \"n_estimators\"]: \r\n self.params[\"n_estimators\"] = n_iter\r\n self._model = CatBoostEstimator._smallmodel\r\n return time.time()-start_time\r\n if budget:\r\n train_times = 1 \r\n self.params[\"n_estimators\"] = min(n_iter, int((budget-time.time()+\r\n start_time-CatBoostEstimator._t1)/train_times/\r\n CatBoostEstimator._time_per_iter+1))\r\n self._model = CatBoostEstimator._smallmodel\r\n if self.params[\"n_estimators\"] > 0:\r\n l = max(int(len(y_train)*0.9), len(y_train)-1000)\r\n X_tr, y_tr = X_train[:l], y_train[:l]\r\n if 'sample_weight' in kwargs:\r\n weight = kwargs['sample_weight']\r\n if weight is not None: kwargs['sample_weight'] = weight[:l]\r\n else: weight = None\r\n from catboost import Pool\r\n model = self.estimator_class(**self.params)\r\n model.fit(X_tr, y_tr, cat_features=cat_features, eval_set=Pool(\r\n data=X_train[l:], label=y_train[l:], cat_features=cat_features),\r\n **kwargs)\r\n if weight is not None: kwargs['sample_weight'] = weight \r\n # print(self.params[\"n_estimators\"], model.get_best_iteration())\r\n self._model = model\r\n self.params[\"n_estimators\"] = n_iter\r\n train_time = time.time() - start_time\r\n # print(budget, train_time)\r\n return train_time\r\n\r\n\r\nclass KNeighborsEstimator(BaseEstimator):\r\n\r\n \r\n @classmethod\r\n def search_space(cls, data_size, **params): \r\n upper = min(512, int(data_size/2))\r\n return {\r\n 'n_neighbors': {\r\n 'domain': tune.qloguniform(lower=1, upper=upper, q=1),\r\n 'init_value': 5,\r\n },\r\n }\r\n\r\n @classmethod\r\n def cost_relative2lgbm(cls):\r\n return 30\r\n\r\n def __init__(self, task='binary:logistic', n_jobs=1,\r\n n_neighbors=5, **params):\r\n super().__init__(task, **params)\r\n self.params= {\r\n 'n_neighbors': int(round(n_neighbors)),\r\n 'weights': 'distance',\r\n 'n_jobs': n_jobs,\r\n }\r\n if 'regression' in task:\r\n from sklearn.neighbors import KNeighborsRegressor\r\n self.estimator_class = KNeighborsRegressor\r\n else:\r\n from sklearn.neighbors import KNeighborsClassifier\r\n self.estimator_class = KNeighborsClassifier\r\n\r\n def _preprocess(self, X):\r\n if isinstance(X, pd.DataFrame):\r\n cat_columns = X.select_dtypes(['category']).columns\r\n # print(X.dtypes)\r\n # print(cat_columns)\r\n if X.shape[1] == len(cat_columns):\r\n raise ValueError(\r\n \"kneighbor requires at least one numeric feature\")\r\n X = X.drop(cat_columns, axis=1) \r\n return X\r\n" ]

[ [ "numpy.issubdtype", "scipy.sparse.issparse" ] ]

haiderstats/survival_evaluation

[ "70e3a4d530a61549609689e3ebd80818f3ab14d9" ]

[ "survival_evaluation/evaluations.py" ]

[ "from typing import Optional\n\nimport numpy as np # type: ignore\nfrom scipy.stats import chi2 # type: ignore\n\nfrom survival_evaluation.types import NumericArrayLike\nfrom survival_evaluation.utility import (\n KaplanMeier,\n KaplanMeierArea,\n to_array,\n validate_size,\n)\n\n\n# pylint: disable=too-many-arguments\ndef l1(\n event_times: NumericArrayLike,\n event_indicators: NumericArrayLike,\n predictions: NumericArrayLike,\n training_event_times: Optional[NumericArrayLike] = None,\n training_event_indicators: Optional[NumericArrayLike] = None,\n l1_type: str = \"hinge\",\n) -> float:\n\n event_times = to_array(event_times)\n event_indicators = to_array(event_indicators, to_boolean=True)\n predictions = to_array(predictions)\n\n validate_size(event_times, event_indicators, predictions)\n if l1_type == \"hinge\":\n scores = event_times - predictions\n scores[~event_indicators] = np.maximum(scores[~event_indicators], 0)\n return np.mean(np.abs(scores))\n\n if l1_type == \"margin\":\n if training_event_times is None or training_event_indicators is None:\n raise ValueError(\n \"If 'margin' is chosen, training set values must be included.\"\n )\n\n training_event_times = to_array(training_event_times)\n training_event_indicators = to_array(training_event_indicators, to_boolean=True)\n\n km_model = KaplanMeierArea(training_event_times, training_event_indicators)\n censor_times = event_times[~event_indicators]\n weights = 1 - km_model.predict(censor_times)\n best_guesses = km_model.best_guess(censor_times)\n\n scores = np.empty(predictions.size)\n scores[event_indicators] = (\n event_times[event_indicators] - predictions[event_indicators]\n )\n scores[~event_indicators] = weights * (\n best_guesses - predictions[~event_indicators]\n )\n weighted_multiplier = 1 / (np.sum(event_indicators) + np.sum(weights))\n return weighted_multiplier * np.sum(np.abs(scores))\n\n raise ValueError(\"L1 type must be either 'hinge' or 'margin'.\")\n\n\n# pylint: disable=too-many-arguments\n# pylint: disable=too-many-locals\ndef one_calibration(\n event_times: NumericArrayLike,\n event_indicators: NumericArrayLike,\n predictions: NumericArrayLike,\n time: float,\n bins: int = 10,\n) -> dict:\n\n event_times = to_array(event_times)\n event_indicators = to_array(event_indicators, to_boolean=True)\n predictions = 1 - to_array(predictions)\n\n prediction_order = np.argsort(-predictions)\n predictions = predictions[prediction_order]\n event_times = event_times[prediction_order]\n event_indicators = event_indicators[prediction_order]\n\n # Can't do np.mean since split array may be of different sizes.\n binned_event_times = np.array_split(event_times, bins)\n binned_event_indicators = np.array_split(event_indicators, bins)\n probability_means = [np.mean(x) for x in np.array_split(predictions, bins)]\n hosmer_lemeshow = 0\n observed_probabilities = list()\n expected_probabilities = list()\n for b in range(bins):\n prob = probability_means[b]\n if prob == 1.0:\n raise ValueError(\n \"One-Calibration is not well defined: the risk\"\n f\"probability of the {b}th bin was {prob}.\"\n )\n km_model = KaplanMeier(binned_event_times[b], binned_event_indicators[b])\n event_probability = 1 - km_model.predict(time)\n bin_count = len(binned_event_times[b])\n hosmer_lemeshow += (bin_count * event_probability - bin_count * prob) ** 2 / (\n bin_count * prob * (1 - prob)\n )\n observed_probabilities.append(event_probability)\n expected_probabilities.append(prob)\n\n return dict(\n p_value=1 - chi2.cdf(hosmer_lemeshow, bins - 1),\n observed=observed_probabilities,\n expected=expected_probabilities,\n )\n\n\ndef d_calibration(\n event_indicators: NumericArrayLike,\n predictions: NumericArrayLike,\n bins: int = 10,\n) -> dict:\n\n event_indicators = to_array(event_indicators, to_boolean=True)\n predictions = to_array(predictions)\n\n # include minimum to catch if probability = 1.\n bin_index = np.minimum(np.floor(predictions * bins), bins - 1).astype(int)\n censored_bin_indexes = bin_index[~event_indicators]\n uncensored_bin_indexes = bin_index[event_indicators]\n\n censored_predictions = predictions[~event_indicators]\n censored_contribution = 1 - (censored_bin_indexes / bins) * (\n 1 / censored_predictions\n )\n censored_following_contribution = 1 / (bins * censored_predictions)\n\n contribution_pattern = np.tril(np.ones([bins, bins]), k=-1).astype(bool)\n\n following_contributions = np.matmul(\n censored_following_contribution, contribution_pattern[censored_bin_indexes]\n )\n single_contributions = np.matmul(\n censored_contribution, np.eye(bins)[censored_bin_indexes]\n )\n uncensored_contributions = np.sum(np.eye(bins)[uncensored_bin_indexes], axis=0)\n bin_count = (\n single_contributions + following_contributions + uncensored_contributions\n )\n chi2_statistic = np.sum(\n np.square(bin_count - len(predictions) / bins) / (len(predictions) / bins)\n )\n return dict(\n p_value=1 - chi2.cdf(chi2_statistic, bins - 1),\n bin_proportions=bin_count / len(predictions),\n censored_contributions=(single_contributions + following_contributions)\n / len(predictions),\n uncensored_contributions=uncensored_contributions / len(predictions),\n )\n" ]

[ [ "numpy.maximum", "numpy.abs", "numpy.eye", "numpy.matmul", "scipy.stats.chi2.cdf", "numpy.ones", "numpy.mean", "numpy.floor", "numpy.argsort", "numpy.array_split", "numpy.sum", "numpy.empty" ] ]

yukyeongleee/CodeTemplate

[ "d0777d501bf64b01ea63787c75b505f7b76ebeda" ]

[ "submodel/resnet.py" ]

[ "import torch.nn as nn\nimport torch.nn.functional as F\nimport torch.utils.model_zoo as modelzoo\nfrom lib.utils import conv3x3\n\n\nresnet18_url = 'https://download.pytorch.org/models/resnet18-5c106cde.pth'\n\n\nclass Resnet18(nn.Module):\n def __init__(self):\n super(Resnet18, self).__init__()\n self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,\n bias=False)\n self.bn1 = nn.BatchNorm2d(64)\n self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n self.layer1 = create_layer_basic(64, 64, bnum=2, stride=1)\n self.layer2 = create_layer_basic(64, 128, bnum=2, stride=2)\n self.layer3 = create_layer_basic(128, 256, bnum=2, stride=2)\n self.layer4 = create_layer_basic(256, 512, bnum=2, stride=2)\n self.init_weight()\n\n def forward(self, x):\n x = self.conv1(x)\n x = F.relu(self.bn1(x))\n x = self.maxpool(x)\n\n x = self.layer1(x)\n feat8 = self.layer2(x) # 1/8\n feat16 = self.layer3(feat8) # 1/16\n feat32 = self.layer4(feat16) # 1/32\n return feat8, feat16, feat32\n\n def init_weight(self):\n state_dict = modelzoo.load_url(resnet18_url)\n self_state_dict = self.state_dict()\n for k, v in state_dict.items():\n if 'fc' in k: continue\n self_state_dict.update({k: v})\n self.load_state_dict(self_state_dict)\n\n def get_params(self):\n wd_params, nowd_params = [], []\n for module in self.named_modules():\n if isinstance(module, (nn.Linear, nn.Conv2d)):\n wd_params.append(module.weight)\n if not module.bias is None:\n nowd_params.append(module.bias)\n elif isinstance(module, nn.BatchNorm2d):\n nowd_params += list(module.parameters())\n return wd_params, nowd_params\n\n\nclass BasicBlock(nn.Module):\n def __init__(self, in_chan, out_chan, stride=1):\n super(BasicBlock, self).__init__()\n self.conv1 = conv3x3(in_chan, out_chan, stride)\n self.bn1 = nn.BatchNorm2d(out_chan)\n self.conv2 = conv3x3(out_chan, out_chan)\n self.bn2 = nn.BatchNorm2d(out_chan)\n self.relu = nn.ReLU(inplace=True)\n self.downsample = None\n if in_chan != out_chan or stride != 1:\n self.downsample = nn.Sequential(\n nn.Conv2d(in_chan, out_chan,\n kernel_size=1, stride=stride, bias=False),\n nn.BatchNorm2d(out_chan),\n )\n\n def forward(self, x):\n residual = self.conv1(x)\n residual = F.relu(self.bn1(residual))\n residual = self.conv2(residual)\n residual = self.bn2(residual)\n\n shortcut = x\n if self.downsample is not None:\n shortcut = self.downsample(x)\n\n out = shortcut + residual\n out = self.relu(out)\n return out\n\n\ndef create_layer_basic(in_chan, out_chan, bnum, stride=1):\n layers = [BasicBlock(in_chan, out_chan, stride=stride)]\n for i in range(bnum-1):\n layers.append(BasicBlock(out_chan, out_chan, stride=1))\n return nn.Sequential(*layers)\n" ]

[ [ "torch.nn.Sequential", "torch.nn.Conv2d", "torch.nn.MaxPool2d", "torch.nn.BatchNorm2d", "torch.nn.ReLU", "torch.utils.model_zoo.load_url" ] ]

ma-kast/AMfe

[ "99686cc313fb8904a093fb42e6cf0b38f8cfd791" ]

[ "amfe/mor/hyper_red/ecsw.py" ]

[ "\"\"\"\nTODO: Write introduction to ECSW\n\"\"\"\n\nimport logging\n\nimport numpy as np\nfrom scipy.linalg import solve as linsolve\nfrom scipy.sparse import csc_matrix\n\nfrom .ecsw_assembly import EcswAssembly\n\n\n__all__ = ['sparse_nnls',\n 'ecsw_assemble_G_and_b',\n 'ecsw_get_weights_by_component',\n 'EcswAssembly']\n\n\ndef sparse_nnls(G, b, tau, conv_stats=True):\n r\"\"\"\n Run the sparse NNLS-solver in order to find a sparse vector xi satisfying\n\n .. math::\n || G \\xi - b ||_2 \\leq \\tau ||b||_2 \\quad\\text{with}\\quad \\min||\\xi||_0\n\n Parameters\n ----------\n G : ndarray, shape: (n*m, no_of_elements)\n force contribution matrix\n b : ndarray, shape: (n*m)\n force contribution vector\n tau : float\n tolerance\n conv_stats : bool\n Flag for setting, that more detailed output is produced with\n convergence information.\n\n Returns\n -------\n x : csc_matrix\n sparse vector containing the weights\n stats : ndarray\n Infos about the convergence of the system. The first column shows the\n size of the active set, the second column the residual. If conv_info is\n set to False, an empty array is returned.\n\n References\n ----------\n .. [1] C. L. Lawson and R. J. Hanson. Solving least squares problems,\n volume 15. SIAM, 1995.\n\n .. [2] T. Chapman, P. Avery, P. Collins, and C. Farhat. Accelerated mesh\n sampling for the hyper reduction of nonlinear computational models.\n International Journal for Numerical Methods in Engineering, 2016.\n\n \"\"\"\n no_of_elements = G.shape[1]\n norm_b = np.linalg.norm(b)\n r = b\n\n xi = np.zeros(no_of_elements) # the resulting vector\n zeta = np.zeros(no_of_elements) # the trial vector which is iterated over\n\n # Boolean active set; allows quick and easys indexing through masking with\n # high performance at the same time\n active_set = np.zeros(no_of_elements, dtype=bool)\n\n stats = []\n while np.linalg.norm(r) > tau * norm_b:\n mu = G.T @ r\n idx = np.argmax(mu)\n if active_set[idx] == True:\n raise RuntimeError('snnls: The index has {} has already been added and is considered to be the best again.')\n active_set[idx] = True\n print('Added element {}'.format(idx))\n while True:\n # Trial vector zeta is solved for the sparse solution\n zeta[~active_set] = 0.0\n G_red = G[:, active_set]\n zeta[active_set] = linsolve(G_red.T @ G_red, G_red.T @ b)\n\n # check, if gathered solution is full positive\n if np.min(zeta[active_set]) >= 0.0:\n xi[:] = zeta[:]\n break\n # remove the negative elements from the active set\n # Get all elements which violate the constraint, i.e. are in the\n # active set and are smaller than zero\n mask = np.logical_and(zeta <= 0.0, active_set)\n\n ele_const = np.argmin(xi[mask] / (xi[mask] - zeta[mask]))\n const_idx = np.where(mask)[0][ele_const]\n print('Remove element {} '.format(const_idx) +\n 'violating the constraint.')\n # Amplify xi with the difference of zeta and xi such, that the\n # largest mismatching negative point becomes zero.\n alpha = np.min(xi[mask] / (xi[mask] - zeta[mask]))\n xi += alpha * (zeta - xi)\n # Set active set manually as otherwise floating point roundoff\n # errors are not considered.\n # active_set = xi != 0\n active_set[const_idx] = False\n\n r = b - G[:, active_set] @ xi[active_set]\n logger = logging.getLogger('amfe.hyper_red.ecsw.snnls')\n logger.debug(\"snnls: residual {} No of active elements: {}\".format(np.linalg.norm(r), len(np.where(xi)[0])))\n if conv_stats:\n stats.append((len(np.where(xi)[0]), np.linalg.norm(r)))\n\n # sp.optimize.nnls(A, b)\n indices = np.where(xi)[0] # remove the nasty tuple from np.where()\n xi_red = xi[active_set]\n indptr = np.array([0, len(xi_red)])\n x = csc_matrix((xi_red, indices, indptr), shape=(G.shape[1], 1))\n if conv_stats and not stats:\n stats.append((0, np.linalg.norm(r)))\n stats = np.array(stats)\n return x, stats\n\n\ndef ecsw_assemble_G_and_b(component, S, W, timesteps=None):\n \"\"\"\n Assembles the element contribution matrix G for the given snapshots S.\n\n This function is needed for cubature bases Hyper reduction methods\n like the ECSW.\n\n Parameters\n ----------\n component : amfe.MeshComponent\n amfe.Component, if a reduction basis should be used, it should already\n be the component that is reduced by this reduction basis\n S : ndarray, shape (no_of_dofs, no_of_snapshots)\n Snapshots gathered as column vectors.\n W : ndarray\n projection matrix\n timesteps : ndarray, shape(no_of_snapshots)\n the timesteps of where the snapshots have been generated can be passed,\n this is important for systems with certain constraints\n\n Returns\n -------\n G : ndarray, shape (n*m, no_of_elements)\n Contribution matrix of internal forces. The columns form the\n internal force contributions on the basis V for the m snapshots\n gathered in S.\n b : ndarray, shape (n*m, )\n summed force contribution\n\n Note\n ----\n This assembly works on constrained variables\n \"\"\"\n # Check the raw dimension\n # Currently not applicable\n # assert(component.no_of_dofs == S.shape[0])\n\n logger = logging.getLogger('amfe.hyper_red.ecsw.ecsw_assemble_G_and_b')\n\n if timesteps is None:\n timesteps = np.zeros(S.shape[1], dtype=float)\n\n no_of_dofs, no_of_snapshots = S.shape\n no_of_reduced_dofs = W.shape[1]\n\n no_of_elements = component.no_of_elements\n logger.info('Start building large selection matrix G. In total {0:d} elements are treated:'.format(\n no_of_elements))\n\n G = np.zeros((no_of_reduced_dofs*no_of_snapshots, no_of_elements))\n\n # Temporarily replace Assembly of component:\n old_assembly = component.assembly\n g_assembly = EcswAssembly([], [])\n component.assembly = g_assembly\n\n # Weight only one element by one\n g_assembly.weights = [1.0]\n\n # Set dq and ddq = 0\n dq = np.zeros(no_of_dofs)\n\n # loop over all elements\n for element_no in range(no_of_elements):\n # Change nonzero weighted elements to current element\n g_assembly.indices = [element_no]\n\n logger.debug('Assemble element {:10d} / {:10d}'.format(element_no+1, no_of_elements))\n # loop over all snapshots\n\n for snapshot_number, (snapshot_vector, t) in enumerate(zip(S.T, timesteps)):\n G[snapshot_number*no_of_reduced_dofs:(snapshot_number+1)*no_of_reduced_dofs, element_no] = W.T @ component.f_int(snapshot_vector,\n dq, t)\n\n b = np.sum(G, axis=1)\n\n # reset assembly\n component.assembly = old_assembly\n return G, b\n\n\ndef ecsw_get_weights_by_component(component, S, W, timesteps=None, tau=0.001, conv_stats=True):\n \"\"\"\n Reduce the given MeshComponent\n\n Parameters\n ----------\n component : instance of MeshComponent\n MeshComponent\n S : ndarray, shape (no_of_dofs, no_of_snapshots)\n Snapshots\n W : ndarray\n projection basis\n timesteps : ndarray, optional\n timesteps of the training snapshots\n if None, all timesteps will be set to zero\n tau : float\n tolerance of the ECSW reduction\n conv_stats : bool\n Flag if conv_stats shall be collected\n\n Returns\n -------\n weights : ndarray\n ecsw weights\n indices : ndarray\n row based indices of elements that have non-zero weights\n stats : ndarray\n convergence stats of the snnls solver\n \"\"\"\n\n if timesteps is None:\n timesteps = np.zeros(S.shape[1], dtype=float)\n\n # Create G and b from snapshots:\n G, b = ecsw_assemble_G_and_b(component, S, W, timesteps)\n\n weights, indices, stats = ecsw_get_weights_by_G_and_b(G, b, tau, conv_stats)\n\n return weights, indices, stats\n\n\ndef ecsw_get_weights_by_G_and_b(G, b, tau, conv_stats):\n # Calculate indices and weights\n x, stats = sparse_nnls(G, b, tau, conv_stats)\n indices = x.indices\n weights = x.data\n\n return weights, indices, stats\n" ]

[ [ "scipy.sparse.csc_matrix", "numpy.logical_and", "numpy.min", "numpy.linalg.norm", "scipy.linalg.solve", "numpy.argmax", "numpy.where", "numpy.argmin", "numpy.array", "numpy.zeros", "numpy.sum" ] ]

neurophysik/jitcdde

[ "44d7ed6ad187d3591407155b6eeb063f73e462cd", "44d7ed6ad187d3591407155b6eeb063f73e462cd", "44d7ed6ad187d3591407155b6eeb063f73e462cd" ]

[ "tests/test_lyaps.py", "examples/two_Roesslers.py", "tests/test_past.py" ]

[ "#!/usr/bin/python3\n# -*- coding: utf-8 -*-\n\n\nimport platform\nimport unittest\nimport numpy as np\nfrom scipy.stats import sem\nfrom jitcdde import t, y, jitcdde_lyap\n\nif platform.system() == \"Windows\":\n\tcompile_args = None\nelse:\n\tfrom jitcxde_common import DEFAULT_COMPILE_ARGS\n\tcompile_args = DEFAULT_COMPILE_ARGS+[\"-g\",\"-UNDEBUG\"]\n\nomega = np.array([0.88167179, 0.87768425])\ndelay = 4.5\n\nf = [\n\tomega[0] * (-y(1) - y(2)),\n\tomega[0] * (y(0) + 0.165 * y(1)),\n\tomega[0] * (0.2 + y(2) * (y(0) - 10.0)),\n\tomega[1] * (-y(4) - y(5)) + 0.25 * (y(0,t-delay) - y(3)),\n\tomega[1] * (y(3) + 0.165 * y(4)),\n\tomega[1] * (0.2 + y(5) * (y(3) - 10.0))\n\t]\n\ntest_parameters = {\n\t\"rtol\": 1e-7,\n\t\"atol\": 1e-7,\n\t\"pws_rtol\": 1e-3,\n\t\"pws_atol\": 1e-3,\n\t\"first_step\": 30,\n\t\"max_step\": 100,\n\t\"min_step\": 1e-30,\n\t}\n\nlyap_controls = [0.0806, 0, -0.0368, -0.1184]\n\nclass TestIntegration(unittest.TestCase):\n\tdef setUp(self):\n\t\tself.DDE = jitcdde_lyap(f, n_lyap=len(lyap_controls))\n\t\tself.DDE.add_past_point(-delay, np.random.random(6), np.random.random(6))\n\t\tself.DDE.add_past_point(0.0, np.random.random(6), np.random.random(6))\n\t\tself.DDE.set_integration_parameters(**test_parameters)\n\t\n\tdef test_integrate_blindly(self):\n\t\tself.DDE.integrate_blindly(100.0, 0.1)\n\t\n\tdef test_step_on_discontinuities(self):\n\t\tself.DDE.step_on_discontinuities()\n\t\n\t## Takes forever:\n\t# def test_Python_core(self):\n\t# \tself.DDE.generate_lambdas(simplify=False)\n\t# \tself.DDE.step_on_discontinuities(max_step=0.1)\n\t\n\tdef tearDown(self):\n\t\tlyaps = []\n\t\tweights = []\n\t\tfor T in np.arange(self.DDE.t, self.DDE.t+1000, 10):\n\t\t\t_, lyap, weight = self.DDE.integrate(T)\n\t\t\tlyaps.append(lyap)\n\t\t\tweights.append(weight)\n\t\tlyaps = np.vstack(lyaps)\n\t\t\n\t\tlyap_start = 40\n\t\tfor i,lyap_control in enumerate(lyap_controls):\n\t\t\tlyap = np.average(lyaps[lyap_start:,i], weights=weights[lyap_start:])\n\t\t\tstderr = sem(lyaps[lyap_start:,i])\n\t\t\tself.assertAlmostEqual(lyap_control, lyap, delta=3*stderr)\n\nclass TestSaveAndLoad(TestIntegration):\n\tdef setUp(self):\n\t\tDDE_orig = jitcdde_lyap(f, n_lyap=len(lyap_controls))\n\t\tfilename = DDE_orig.save_compiled(overwrite=True)\n\t\tself.DDE = jitcdde_lyap(\n\t\t\tn=6,\n\t\t\tmodule_location=filename,\n\t\t\tdelays=[delay],\n\t\t\tn_lyap=len(lyap_controls)\n\t\t\t)\n\t\tself.DDE.add_past_point(-delay, np.random.random(6), np.random.random(6))\n\t\tself.DDE.add_past_point(0.0, np.random.random(6), np.random.random(6))\n\t\tself.DDE.set_integration_parameters(**test_parameters)\n\nclass TestOMP(TestIntegration):\n\tdef setUp(self):\n\t\tself.DDE = jitcdde_lyap(f, n_lyap=len(lyap_controls))\n\t\tself.DDE.add_past_point(-delay, np.random.random(6), np.random.random(6))\n\t\tself.DDE.add_past_point(0.0, np.random.random(6), np.random.random(6))\n\t\tself.DDE.set_integration_parameters(**test_parameters)\n\t\tself.DDE.compile_C(omp=True,chunk_size=15)\n\t\nif __name__ == \"__main__\":\n\tunittest.main(buffer=True)\n\n", "from jitcdde import t, y, jitcdde\nimport numpy as np\n\nω = np.random.normal(0.89, 0.0089, 2)\nk = 0.25\ndelay = 4.5\n\nf = [\n\tω[0] * (-y(1) - y(2)),\n\tω[0] * (y(0) + 0.165 * y(1)),\n\tω[0] * (0.2 + y(2) * (y(0) - 10.0)),\n\tω[1] * (-y(4) - y(5)) + k * (y(0,t-delay) - y(3)),\n\tω[1] * (y(3) + 0.165 * y(4)),\n\tω[1] * (0.2 + y(5) * (y(3) - 10.0))\n\t]\n\nDDE = jitcdde(f)\n\nstart_state = np.random.uniform(-0.5,0.5,6)\n\nDDE.add_past_point(-delay, start_state, np.zeros(6))\nDDE.add_past_point(0.0 , start_state, np.zeros(6))\n\nDDE.step_on_discontinuities()\n\ntimes = np.arange(DDE.t,DDE.t+1000,0.1)\ndata = np.vstack([ DDE.integrate(T) for T in times ])\nnp.savetxt(\"two_roesslers.dat\", data)\n\n", "#!/usr/bin/python3\n# -*- coding: utf-8 -*-\n\nfrom jitcdde.past import Past\n\nimport symengine\nimport numpy as np\nfrom numpy.testing import assert_allclose\nimport unittest\n\n\nclass normalisation_test(unittest.TestCase):\n\tdef test_orthonormalisation(self):\n\t\tm = 4\n\t\tpast = Past(n=m,anchors=[\n\t\t\t\t(time, np.random.normal(0,1,m), np.random.normal(0,1,m))\n\t\t\t\tfor time in sorted(np.random.uniform(-3,0,5))\n\t\t\t])\n\t\tdelay = np.random.uniform(0.0,2.0)\n\t\tpast.orthonormalise(m-1, delay)\n\t\t\n\t\tfor j in range(1,m):\n\t\t\tself.assertAlmostEqual(past.norm(delay, j), 1.0)\n\t\t\t\n\t\t\tfor k in range(j,m):\n\t\t\t\tcontrol = 1.0 if k==j else 0.0\n\t\t\t\tsp = past.scalar_product(delay, j, k)\n\t\t\t\tself.assertAlmostEqual(sp, control)\n\nclass remove_projection_test(unittest.TestCase):\n\tdef setUp(self):\n\t\tself.n_basic = 3\n\t\tself.n = 6*self.n_basic\n\t\t\n\t\tself.original_past = Past(n=self.n,n_basic=self.n_basic)\n\t\tfor i in range(np.random.randint(3,10)):\n\t\t\tif i==0:\n\t\t\t\ttime = np.random.uniform(-10,10)\n\t\t\telse:\n\t\t\t\ttime = self.original_past[-1][0] + 0.1 + np.random.random()\n\t\t\tstate = np.random.random(self.n)\n\t\t\tdiff = np.random.random(self.n)\n\t\t\tself.original_past.append((time, state, diff))\n\t\t\n\t\tself.past = self.original_past.copy()\n\t\n\tdef test_remove_first_component(self):\n\t\tempty = lambda: np.zeros(self.n_basic)\n\t\tvectors = [\n\t\t\t\t(empty(), empty()),\n\t\t\t\t(empty(), empty())\n\t\t\t]\n\t\tcomponent = np.random.randint(0,self.n_basic)\n\t\tvectors[0][0][component] = 1\n\t\tvectors[1][1][component] = 1\n\t\tdelay = self.original_past[-1][0]-self.original_past[0][0]\n\t\t\n\t\tself.past.remove_projections(delay, vectors)\n\t\tfor anchor in self.past:\n\t\t\tself.assertAlmostEqual(anchor[1][self.n_basic+component], 0.0)\n\t\t\tself.assertAlmostEqual(anchor[2][self.n_basic+component], 0.0)\n\t\n\tdef test_double_removal(self):\n\t\trandom_vector = lambda: np.random.random(self.n_basic)\n\t\tvectors = [\n\t\t\t(random_vector(), random_vector()),\n\t\t\t(random_vector(), random_vector())\n\t\t\t]\n\t\tdelay = (self.original_past[-1][0]-self.original_past[0][0])*np.random.uniform(0.5,1.5)\n\t\t\n\t\tself.past.remove_projections(delay, vectors)\n\t\tpast_copy = [(anchor[0], np.copy(anchor[1]), np.copy(anchor[2])) for anchor in self.past]\n\t\tfor anchor_A, anchor_B in zip(past_copy, self.past):\n\t\t\tassert_allclose(anchor_A[1], anchor_B[1])\n\t\t\tassert_allclose(anchor_A[2], anchor_B[2])\n\t\t\n\t\tnorm = self.past.remove_projections(delay, vectors)\n\t\tself.assertAlmostEqual(norm, 1.0)\n\t\t\n\t\tfor anchor_A, anchor_B in zip(past_copy, self.past):\n\t\t\tassert_allclose(anchor_A[1], anchor_B[1])\n\t\t\tassert_allclose(anchor_A[2], anchor_B[2])\n\nif __name__ == \"__main__\":\n\tunittest.main(buffer=True)\n\n" ]

[ [ "numpy.random.random", "numpy.arange", "numpy.average", "scipy.stats.sem", "numpy.array", "numpy.vstack" ], [ "numpy.arange", "numpy.random.normal", "numpy.savetxt", "numpy.random.uniform", "numpy.zeros" ], [ "numpy.random.random", "numpy.copy", "numpy.random.normal", "numpy.testing.assert_allclose", "numpy.random.uniform", "numpy.zeros", "numpy.random.randint" ] ]

arj119/adaptive-federated-learning

[ "6c22d65c3a46a0b293dc5ddd4cd579f6010445f5" ]

[ "control_algorithm/adaptive_tau.py" ]

[ "import math\nimport numpy as np\nfrom numpy import linalg\nfrom util.utils import recv_msg, send_msg, moving_average\nfrom config import tau_max\n\n\nclass ControlAlgAdaptiveTauServer:\n def __init__(self, is_adapt_local, dim_w, client_sock_all, n_nodes, control_param_phi,\n moving_average_holding_param):\n\n self.is_adapt_local = is_adapt_local\n self.dim_w = dim_w\n self.client_sock_all = client_sock_all\n self.n_nodes = n_nodes\n self.control_param_phi = control_param_phi\n self.moving_average_holding_param = moving_average_holding_param\n\n self.beta_adapt_mvaverage = None\n self.delta_adapt_mvaverage = None\n self.rho_adapt_mvaverage = None\n\n def compute_new_tau(self, data_size_local_all, data_size_total, it_each_local, it_each_global, max_time,\n step_size, tau, use_min_loss):\n\n beta_adapt = 0\n delta_adapt = 0\n rho_adapt = 0\n global_grad_global_weight = np.zeros(self.dim_w)\n\n local_grad_global_weight_all = []\n\n control_param_computed = False\n for n in range(0, self.n_nodes):\n msg = recv_msg(self.client_sock_all[n], 'MSG_CONTROL_PARAM_COMPUTED_CLIENT_TO_SERVER')\n # ['MSG_CONTROL_PARAM_COMPUTED_CLIENT_TO_SERVER', control_param_computed]\n control_param_computed_this_client = msg[1] # Boolean parameter specifying whether parameters for\n # control algorithm follows this message\n\n control_param_computed = control_param_computed or control_param_computed_this_client\n\n # Receive additional message for control algorithm if it has been computed\n if control_param_computed_this_client:\n msg = recv_msg(self.client_sock_all[n], 'MSG_BETA_RHO_GRAD_CLIENT_TO_SERVER')\n # ['MSG_BETA_RHO_GRAD_CLIENT_TO_SERVER', betaAdapt, rhoAdapt, localGradGlobalWeight]\n\n beta_adapt_local = msg[1]\n rho_adapt_local = msg[2]\n local_grad_global_weight = msg[3]\n\n local_grad_global_weight_all.append(local_grad_global_weight)\n\n beta_adapt += data_size_local_all[n] * beta_adapt_local\n rho_adapt += data_size_local_all[n] * rho_adapt_local\n global_grad_global_weight += data_size_local_all[n] * local_grad_global_weight\n\n global_grad_global_weight /= data_size_total\n\n if control_param_computed and (it_each_local is not None) and (it_each_global is not None):\n # finalize beta and delta computation when using control algorithm\n beta_adapt /= data_size_total\n rho_adapt /= data_size_total\n\n for i in range(0, self.n_nodes):\n delta_adapt += data_size_local_all[i] * linalg.norm(local_grad_global_weight_all[i]\n - global_grad_global_weight)\n delta_adapt /= data_size_total\n\n # compute moving averages\n self.beta_adapt_mvaverage = moving_average(self.beta_adapt_mvaverage, beta_adapt, self.moving_average_holding_param)\n self.delta_adapt_mvaverage = moving_average(self.delta_adapt_mvaverage, delta_adapt, self.moving_average_holding_param)\n self.rho_adapt_mvaverage = moving_average(self.rho_adapt_mvaverage, rho_adapt, self.moving_average_holding_param)\n\n print('betaAdapt_mvaverage =', self.beta_adapt_mvaverage)\n print('deltaAdapt_mvaverage =', self.delta_adapt_mvaverage)\n print('rhoAdapt_mvaverage =', self.rho_adapt_mvaverage)\n\n # Find tau if using control algorithm\n if self.is_adapt_local:\n\n # Find new optimal tau\n min_tau_new_tmp = 1\n min_val = float('inf')\n\n for tau_new_tmp in range(1, tau * 10 + 1):\n h_tau_tmp = max(0.0, (self.delta_adapt_mvaverage / self.beta_adapt_mvaverage) * (\n np.power(step_size * self.beta_adapt_mvaverage + 1,\n tau_new_tmp) - 1) - self.delta_adapt_mvaverage * step_size * tau_new_tmp)\n\n # The below lines are the new expression, with betaAdapt and rhoAdapt, and additional term of ht\n if use_min_loss:\n tmp_adjusted_T = (max_time - it_each_local - it_each_global) * tau_new_tmp / \\\n (it_each_local * tau_new_tmp + it_each_global)\n else:\n tmp_adjusted_T = max_time * tau_new_tmp / (it_each_local * tau_new_tmp + it_each_global)\n\n tmp_gap = (1 + math.sqrt(max(0.0, 1 + 4 * math.pow(tmp_adjusted_T, 2.0)\n * self.control_param_phi * self.rho_adapt_mvaverage\n * step_size * h_tau_tmp / tau_new_tmp))) / (\n 2 * tmp_adjusted_T * step_size * self.control_param_phi) + self.rho_adapt_mvaverage * h_tau_tmp\n\n if tmp_gap < min_val:\n min_val = tmp_gap\n min_tau_new_tmp = tau_new_tmp\n\n tau_new = min_tau_new_tmp\n else:\n tau_new = tau\n else:\n tau_new = tau\n\n return min(tau_new, tau_max)\n\n def __getstate__(self):\n # To remove socket from pickle\n state = self.__dict__.copy()\n del state['client_sock_all']\n return state\n\n\nclass ControlAlgAdaptiveTauClient:\n def __init__(self):\n self.w_last_local_last_round = None\n self.grad_last_local_last_round = None\n self.loss_last_local_last_round = None\n\n def init_new_round(self, w):\n self.control_param_computed = False\n self.beta_adapt = None\n self.rho_adapt = None\n self.grad_last_global = None\n\n def update_after_each_local(self, iteration_index, w, grad, total_iterations):\n if iteration_index == 0:\n self.grad_last_global = grad\n\n return False\n\n def update_after_all_local(self, model, train_image, train_label, train_indices,\n w, w_last_global, loss_last_global):\n\n # Only compute beta and rho locally, delta can only be computed globally\n if (self.w_last_local_last_round is not None) and (self.grad_last_local_last_round is not None) and \\\n (self.loss_last_local_last_round is not None):\n\n # compute beta\n c = self.grad_last_local_last_round - self.grad_last_global\n tmp_norm = linalg.norm(self.w_last_local_last_round - w_last_global)\n if tmp_norm > 1e-10:\n self.beta_adapt = linalg.norm(c) / tmp_norm\n else:\n self.beta_adapt = 0\n\n # Compute rho\n if tmp_norm > 1e-10:\n self.rho_adapt = linalg.norm(self.loss_last_local_last_round - loss_last_global) / tmp_norm\n else:\n self.rho_adapt = 0\n\n if self.beta_adapt < 1e-5 or np.isnan(self.beta_adapt):\n self.beta_adapt = 1e-5\n\n if np.isnan(self.rho_adapt):\n self.rho_adapt = 0\n\n print('betaAdapt =', self.beta_adapt)\n\n self.control_param_computed = True\n\n self.grad_last_local_last_round = model.gradient(train_image, train_label, w, train_indices)\n\n try:\n self.loss_last_local_last_round = model.loss_from_prev_gradient_computation()\n except: # Will get an exception if the model does not support computing loss from previous gradient computation\n self.loss_last_local_last_round = model.loss(train_image, train_label, w, train_indices)\n\n self.w_last_local_last_round = w\n\n def send_to_server(self, sock):\n\n msg = ['MSG_CONTROL_PARAM_COMPUTED_CLIENT_TO_SERVER', self.control_param_computed]\n send_msg(sock, msg)\n\n if self.control_param_computed:\n msg = ['MSG_BETA_RHO_GRAD_CLIENT_TO_SERVER', self.beta_adapt, self.rho_adapt, self.grad_last_global]\n send_msg(sock, msg)\n\n" ]

[ [ "numpy.isnan", "numpy.zeros", "numpy.linalg.norm", "numpy.power" ] ]

PhilippPelz/scikit-pr-open

[ "50833b13160b6afe0a743d63d560bddeee2c18b5" ]

[ "skpr/nn/_functions/Broadcast.py" ]

[ "import torch as th\nfrom torch.autograd import Function\n\nimport skpr.inout as io\n\n\nclass Broadcast(Function):\n @staticmethod\n def forward(ctx, input, ntimes, divide_by_ntimes=True):\n io.logger.debug('Broadcast forward 1')\n # out = input.clone()\n # print 'Broadcast.forward'\n ctx.ntimes = ntimes\n ctx.divide_by_ntimes = divide_by_ntimes\n io.logger.debug('Broadcast forward 2')\n return input.view(1, *input.size()).expand(ntimes, *input.size())\n\n @staticmethod\n def backward(ctx, grad_output):\n io.logger.debug('Broadcast backward 1')\n # p.var['dCMul'] = grad_output.data.cpu().squeeze().numpy()\n grad_input = th.sum(grad_output, 0)\n if ctx.divide_by_ntimes:\n grad_input.data.div_(ctx.ntimes)\n # p.var['dP'] = grad_input.data.cpu().numpy()\n io.logger.debug('Broadcast backward 2')\n return grad_input, None, None\n" ]

[ [ "torch.sum" ] ]

k4ntz/XmodRL

[ "dffb416bcd91010d8075ee1ac00cc4b9a3021967" ]

[ "src/xrl/algorithms/minidr/dataset.py" ]

[ "import numpy as np\nimport torch\nfrom torch._C import dtype\nimport torch.nn as nn\nfrom torch.utils.data import Dataset\n\nclass ModelDataset(Dataset):\n def __init__(self, history, history_size):\n self.h = history #history is passed as list and updated outside\n self.history_size = history_size\n\n def __len__(self):\n return self.history_size\n\n def __getitem__(self, idx):\n idx = idx % len(self.h) #do not exceed history length\n episode = self.h[idx]\n\n idx_sample = np.random.randint(0, (len(episode)-1)//4) #sample random part of episode\n\n # one entry is last state, action, state and reward as seperate entries\n last_states = episode[idx_sample * 4]\n actions= episode[idx_sample * 4 + 1]\n states = episode[idx_sample * 4 + 2]\n rewards= episode[idx_sample * 4 + 3]\n\n # flatten raw features list\n last_states = [[0,0] if x==None else x for x in last_states]\n last_states = np.array(np.array(last_states).tolist()).flatten()\n # convert to tensor\n last_states = torch.tensor(last_states).float()\n actions = torch.tensor(actions)\n states = torch.tensor(np.array(states.tolist()).flatten()).float()\n rewards = torch.tensor(rewards)\n\n return last_states, actions, states, rewards" ]

[ [ "numpy.array", "torch.tensor" ] ]

saarimrahman/imagenet-testbed

[ "55a867d091c7193225880010853ed2b4b0b73ec9" ]

[ "plotting/paper_hyp_robust_imagenetv2.py" ]

[ "import os\nfrom os.path import join, exists\nimport argparse\nimport pathlib\nfrom enum import Enum\n\nimport click\nimport numpy as np\nimport pandas as pd\n\nimport download_data\nimport dataframe\nimport plotter\nfrom model_types import ModelTypes, model_types_map\n\n\nclass HypModelTypes(Enum):\n HYP_ROBUST = ('Hypothetical robust model', 'tab:green', 400)\n STANDARD = ('Standard models', 'tab:blue', 150)\n\n\nmodels = [k for k, v in model_types_map.items() if v == ModelTypes.STANDARD]\nmodels = [m for m in models if 'subsample' not in m and 'batch64' not in m and 'aws' not in m]\n\n\ndef get_model_type(df_row):\n if df_row.name in models:\n return HypModelTypes.STANDARD\n\n\ndef show_in_plot(df_row):\n model_name, model_type = df_row.name.lower(), df_row.model_type\n return True\n\n\ndef use_for_line_fit(df_row):\n model_name, model_type, in_plot = df_row.name.lower(), df_row.model_type, df_row.show_in_plot\n return True\n\n\[email protected]()\[email protected]('--x_axis', type=str, default='val')\[email protected]('--y_axis', type=str, default='imagenetv2-matched-frequency-format-val')\[email protected]('--transform', type=str, default='logit')\[email protected]('--output_dir', type=str, default=str((pathlib.Path(__file__).parent / '../outputs').resolve()))\[email protected]('--output_file_dir', type=str, default=str((pathlib.Path(__file__).parent / '../paper/figs').resolve()))\[email protected]('--skip_download', is_flag=True, type=bool)\ndef generate_xy_plot(x_axis, y_axis, transform, output_dir, output_file_dir, skip_download):\n\n if skip_download:\n filename = join(output_dir, 'grid_df.pkl')\n if not exists(filename):\n raise Exception(f'Downloaded data not found at {filename}. Please run python src/plotting/download_data.py first')\n df = pd.read_pickle(filename)\n else:\n df = download_data.download_plotting_data(output_dir, store_data=True, verbose=True)\n\n df, df_metadata = dataframe.extract_metadata(df)\n df, df_metadata = dataframe.replace_10percent_with_metadata(df, df_metadata)\n df, df_metadata = dataframe.aggregate_corruptions_with_metadata(df, df_metadata)\n\n df = prepare_df_for_plotting(df, df_metadata, [x_axis, y_axis])\n df = plotter.add_plotting_data(df, [x_axis, y_axis])\n df = df.dropna()\n\n hyp_robust_model = df.loc['vgg19'].copy()\n arrow_params = (hyp_robust_model['val'], hyp_robust_model['imagenetv2-matched-frequency-format-val']+0.3, 0, 0.285)\n hyp_robust_model.model_type = HypModelTypes.HYP_ROBUST\n hyp_robust_model['imagenetv2-matched-frequency-format-val'] += 8\n hyp_robust_model.name = 'vgg19_hyp_robust'\n hyp_robust_model.use_for_line_fit = False\n df = df.append(hyp_robust_model)\n\n # auto set xlim and ylim based on visible points\n df_visible = df[df.show_in_plot == True]\n xlim = [df_visible[x_axis].min() - 1, df_visible[x_axis].max() + 1]\n ylim = [df_visible[y_axis].min() - 2, df_visible[y_axis].values.max() + 2]\n\n fig, ax = plotter.model_scatter_plot_hyp(df, x_axis, y_axis, xlim, ylim, HypModelTypes, \n transform=transform, tick_multiplier=5,\n title='Hypothetical Robustness Intervention', x_label='ImageNet', y_label='ImageNetV2', \n figsize=(12, 9), include_legend=True, return_separate_legend=False, alpha=0.7, arrow_params=arrow_params)\n\n l = ax.legend(loc='lower right',\n ncol=1,\n bbox_to_anchor=(1, 0),\n fontsize=plotter.legend_fontsize,\n scatterpoints=1,\n columnspacing=0,\n handlelength=1.5,\n borderpad=0.2)\n\n for i, x in enumerate(l.legendHandles):\n x._sizes = [100]\n if i == 2:\n x._sizes = [400]\n\n os.makedirs(output_file_dir, exist_ok=True)\n\n fig.savefig(join(output_file_dir, f'hyp_robust_imagenetv2.pdf'), dpi='figure', bbox_inches='tight', pad_inches=0.1)\n print(f\"Plot saved to {join(output_file_dir, f'hyp_robust_imagenetv2.pdf')}\")\n\n\ndef prepare_df_for_plotting(df, df_metadata, columns):\n assert set(columns).issubset(set(df.columns))\n\n df = df[columns]\n df_metadata = df_metadata[[x+'_dataset_size' for x in columns]]\n df = df.merge(df_metadata, right_index=True, left_index=True)\n df = df.dropna()\n\n df['model_type'] = df.apply(get_model_type, axis=1)\n df['show_in_plot'] = df.apply(show_in_plot, axis=1)\n df['use_for_line_fit'] = df.apply(use_for_line_fit, axis=1)\n\n return df\n\n\nif __name__ == '__main__':\n generate_xy_plot()\n" ]

[ [ "pandas.read_pickle" ] ]

tjingrant/onnx-tf

[ "3412d86238bf99bf4908e829af115693df161988" ]

[ "test/test_model.py" ]

[ "from __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __future__ import unicode_literals\n\nimport unittest\nimport numpy as np\nimport tensorflow as tf\nimport onnx\nfrom onnx_tf.backend import run_node, prepare\nfrom onnx import helper\nfrom onnx.onnx_pb2 import TensorProto\n\nclass TestModel(unittest.TestCase):\n \"\"\" Tests for models\n \"\"\"\n def test_relu_node_inplace(self):\n X = np.random.randn(3, 2).astype(np.float32)\n Y_ref = np.clip(X, 0, np.inf)\n\n node_def = helper.make_node(\n \"Relu\", [\"X\"], [\"X\"])\n\n graph_def = helper.make_graph(\n [node_def],\n name=\"test\",\n inputs=[helper.make_tensor_value_info(\"X\", TensorProto.FLOAT, [3, 2])],\n outputs=[helper.make_tensor_value_info(\"X\", TensorProto.FLOAT, [3, 2])])\n tf_rep = prepare(helper.make_model(graph_def))\n output = tf_rep.run({\"X\": X})\n np.testing.assert_almost_equal(output.X, Y_ref)\n\n def test_initializer(self):\n X = np.array([[1, 2], [3, 4]]).astype(np.float32)\n Y = np.array([[1, 2], [3, 4]]).astype(np.float32)\n weight = np.array([[1, 0], [0, 1]])\n graph_def = helper.make_graph(\n [helper.make_node(\"Add\", [\"X\", \"Y\"], [\"Z0\"]),\n helper.make_node(\"Cast\", [\"Z0\"], [\"Z\"], to=\"float\"),\n helper.make_node(\"Mul\", [\"Z\", \"weight\"], [\"W\"]),\n helper.make_node(\"Tanh\", [\"W\"], [\"W\"]),\n helper.make_node(\"Sigmoid\", [\"W\"], [\"W\"])],\n name=\"test_initializer\",\n inputs=[\n helper.make_tensor_value_info(\"X\", TensorProto.FLOAT, (2, 2)),\n helper.make_tensor_value_info(\"Y\", TensorProto.FLOAT, (2, 2)),\n helper.make_tensor_value_info(\"weight\", TensorProto.FLOAT, (2, 2)),\n ],\n outputs=[\n helper.make_tensor_value_info(\"W\", TensorProto.FLOAT, (2, 2))\n ],\n initializer=[helper.make_tensor(\"weight\",\n TensorProto.FLOAT,\n [2, 2],\n weight.flatten().astype(float))]\n )\n\n def sigmoid(x):\n return 1 / (1 + np.exp(-x))\n\n W_ref = sigmoid(np.tanh((X + Y) * weight))\n tf_rep = prepare(helper.make_model(graph_def))\n output = tf_rep.run({\"X\": X, \"Y\": Y})\n np.testing.assert_almost_equal(output[\"W\"], W_ref)\n\nif __name__ == '__main__':\n unittest.main()\n" ]

[ [ "numpy.clip", "numpy.testing.assert_almost_equal", "numpy.random.randn", "numpy.exp", "numpy.array", "numpy.tanh" ] ]

tien1504/idinvert_pytorch

[ "19999e9945aef4843a464930426a565256863ded" ]

[ "mix_style.py" ]

[ "# python 3.6\n\"\"\"Mixes styles with In-domain GAN Inversion.\n\nThe real images should be first inverted to latent codes with `invert.py`. After\nthat, this script can be used for style mixing.\n\nNOTE: This script will mix every `style-content` image pair from style\ndirectory to content directory.\n\"\"\"\n\nimport os\nimport argparse\nfrom tqdm import tqdm\nimport numpy as np\n\nfrom models.helper import build_generator\nfrom utils.logger import setup_logger\nfrom utils.editor import mix_style\nfrom utils.visualizer import load_image\nfrom utils.visualizer import HtmlPageVisualizer\n\n\ndef parse_args():\n \"\"\"Parses arguments.\"\"\"\n parser = argparse.ArgumentParser()\n parser.add_argument('model_name', type=str, help='Name of the GAN model.')\n parser.add_argument('style_dir', type=str,\n help='Style directory, which includes original images, '\n 'inverted codes, and image list.')\n parser.add_argument('content_dir', type=str,\n help='Content directory, which includes original images, '\n 'inverted codes, and image list.')\n parser.add_argument('-o', '--output_dir', type=str, default='',\n help='Directory to save the results. If not specified, '\n '`./results/style_mixing` will be used by default.')\n parser.add_argument('--mix_layer_start_idx', type=int, default=10,\n help='0-based layer index. Style mixing is performed '\n 'from this layer to the last layer. (default: 10)')\n parser.add_argument('--viz_size', type=int, default=256,\n help='Image size for visualization. (default: 256)')\n parser.add_argument('--gpu_id', type=str, default='0',\n help='Which GPU(s) to use. (default: `0`)')\n return parser.parse_args()\n\n\ndef main():\n \"\"\"Main function.\"\"\"\n args = parse_args()\n os.environ[\"CUDA_VISIBLE_DEVICES\"] = args.gpu_id\n style_dir = args.style_dir\n style_dir_name = os.path.basename(style_dir.rstrip('/'))\n assert os.path.exists(style_dir)\n assert os.path.exists(f'{style_dir}/image_list.txt')\n assert os.path.exists(f'{style_dir}/inverted_codes.npy')\n content_dir = args.content_dir\n content_dir_name = os.path.basename(content_dir.rstrip('/'))\n assert os.path.exists(content_dir)\n assert os.path.exists(f'{content_dir}/image_list.txt')\n assert os.path.exists(f'{content_dir}/inverted_codes.npy')\n output_dir = args.output_dir or 'results/style_mixing'\n job_name = f'{style_dir_name}_STYLIZE_{content_dir_name}'\n logger = setup_logger(output_dir, f'{job_name}.log', f'{job_name}_logger')\n\n # Load model.\n logger.info(f'Loading generator.')\n generator = build_generator(args.model_name)\n mix_layers = list(range(args.mix_layer_start_idx, generator.num_layers))\n\n # Load image and codes.\n logger.info(f'Loading images and corresponding inverted latent codes.')\n style_list = []\n with open(f'{style_dir}/image_list.txt', 'r') as f:\n for line in f:\n name = os.path.splitext(os.path.basename(line.strip()))[0]\n assert os.path.exists(f'{style_dir}/{name}_ori.png')\n style_list.append(name)\n logger.info(f'Loading inverted latent codes.')\n style_codes = np.load(f'{style_dir}/inverted_codes.npy')\n assert style_codes.shape[0] == len(style_list)\n num_styles = style_codes.shape[0]\n content_list = []\n with open(f'{content_dir}/image_list.txt', 'r') as f:\n for line in f:\n name = os.path.splitext(os.path.basename(line.strip()))[0]\n assert os.path.exists(f'{content_dir}/{name}_ori.png')\n content_list.append(name)\n logger.info(f'Loading inverted latent codes.')\n content_codes = np.load(f'{content_dir}/inverted_codes.npy')\n assert content_codes.shape[0] == len(content_list)\n num_contents = content_codes.shape[0]\n\n # Mix styles.\n logger.info(f'Start style mixing.')\n viz_size = None if args.viz_size == 0 else args.viz_size\n visualizer = HtmlPageVisualizer(\n num_rows=num_styles + 1, num_cols=num_contents + 1, viz_size=viz_size)\n visualizer.set_headers(\n ['Style'] +\n [f'Content {i:03d}' for i in range(num_contents)]\n )\n for style_idx, style_name in enumerate(style_list):\n style_image = load_image(f'{style_dir}/{style_name}_ori.png')\n visualizer.set_cell(style_idx + 1, 0, image=style_image)\n for content_idx, content_name in enumerate(content_list):\n content_image = load_image(f'{content_dir}/{content_name}_ori.png')\n visualizer.set_cell(0, content_idx + 1, image=content_image)\n\n codes = mix_style(style_codes=style_codes,\n content_codes=content_codes,\n num_layers=generator.num_layers,\n mix_layers=mix_layers)\n for style_idx in tqdm(range(num_styles), leave=False):\n output_images = generator.easy_synthesize(\n codes[style_idx], latent_space_type='wp')['image']\n for content_idx, output_image in enumerate(output_images):\n visualizer.set_cell(style_idx + 1, content_idx + 1, image=output_image)\n\n # Save results.\n visualizer.save(f'{output_dir}/{job_name}.html')\n\n\nif __name__ == '__main__':\n main()\n" ]

[ [ "numpy.load" ] ]

valeoai/POCO

[ "c6ab56b1b7f01c51d1bc6987eae0a8c79725e63f" ]

[ "lightconvpoint/nn/conv_fkaconv.py" ]

[ "import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom math import ceil\n# from lightconvpoint.spatial import knn, sampling_quantized\nfrom lightconvpoint.utils.functional import batch_gather\nimport torch\n\nclass Convolution_FKAConv(torch.nn.Module):\n\n\n def __init__(self, in_channels, out_channels, kernel_size=16, bias=False, dim=3, kernel_separation=False, adaptive_normalization=True,**kwargs):\n super().__init__()\n\n # parameters\n self.in_channels = in_channels\n self.out_channels = out_channels\n self.kernel_size = kernel_size\n self.bias = bias\n self.dim = dim\n self.adaptive_normalization = adaptive_normalization\n\n # convolution kernel\n if kernel_separation:\n # equivalent to two kernels K1 * K2\n dm = int(ceil(self.out_channels / self.in_channels))\n self.cv = nn.Sequential(\n nn.Conv2d(in_channels, dm*in_channels, (1, kernel_size), bias=bias, groups=self.in_channels),\n nn.Conv2d(in_channels*dm, out_channels, (1, 1), bias=bias)\n )\n else:\n self.cv = nn.Conv2d(in_channels, out_channels, (1, kernel_size), bias=bias)\n\n # normalization radius\n if self.adaptive_normalization:\n self.norm_radius_momentum = 0.1\n self.norm_radius = nn.Parameter(torch.Tensor(1,), requires_grad=False)\n self.alpha = nn.Parameter(torch.Tensor(1,), requires_grad=True)\n self.beta = nn.Parameter(torch.Tensor(1,), requires_grad=True)\n torch.nn.init.ones_(self.norm_radius.data)\n torch.nn.init.ones_(self.alpha.data)\n torch.nn.init.ones_(self.beta.data)\n\n # features to kernel weights\n self.fc1 = nn.Conv2d(self.dim, self.kernel_size, 1, bias=False)\n self.fc2 = nn.Conv2d(2 * self.kernel_size, self.kernel_size, 1, bias=False)\n self.fc3 = nn.Conv2d(2 * self.kernel_size, self.kernel_size, 1, bias=False)\n self.bn1 = nn.InstanceNorm2d(self.kernel_size, affine=True)\n self.bn2 = nn.InstanceNorm2d(self.kernel_size, affine=True)\n\n\n\n def fixed_normalization(self, pts, radius=None):\n maxi = torch.sqrt((pts.detach() ** 2).sum(1).max(2)[0])\n maxi = maxi + (maxi == 0)\n return pts / maxi.view(maxi.size(0), 1, maxi.size(1), 1)\n\n\n\n def forward(self, x, pos, support_points, neighbors_indices):\n\n if x is None:\n return None\n\n pos = batch_gather(pos, dim=2, index=neighbors_indices).contiguous()\n x = batch_gather(x, dim=2, index=neighbors_indices).contiguous()\n\n # center the neighborhoods (local coordinates)\n pts = pos - support_points.unsqueeze(3)\n\n\n # normalize points\n if self.adaptive_normalization:\n\n\n # compute distances from points to their support point\n distances = torch.sqrt((pts.detach() ** 2).sum(1))\n\n # update the normalization radius\n if self.training:\n mean_radius = distances.max(2)[0].mean()\n self.norm_radius.data = (\n self.norm_radius.data * (1 - self.norm_radius_momentum)\n + mean_radius * self.norm_radius_momentum\n )\n\n # normalize\n pts = pts / self.norm_radius\n\n # estimate distance weights\n distance_weight = torch.sigmoid(-self.alpha * distances + self.beta)\n distance_weight_s = distance_weight.sum(2, keepdim=True)\n distance_weight_s = distance_weight_s + (distance_weight_s == 0) + 1e-6\n distance_weight = (\n distance_weight / distance_weight_s * distances.shape[2]\n ).unsqueeze(1)\n\n # feature weighting matrix estimation\n if pts.shape[3] == 1:\n mat = F.relu(self.fc1(pts))\n else:\n mat = F.relu(self.bn1(self.fc1(pts)))\n mp1 = torch.max(mat * distance_weight, dim=3, keepdim=True)[0].expand(\n (-1, -1, -1, mat.shape[3])\n )\n mat = torch.cat([mat, mp1], dim=1)\n if pts.shape[3] == 1:\n mat = F.relu(self.fc2(mat))\n else:\n mat = F.relu(self.bn2(self.fc2(mat)))\n mp2 = torch.max(mat * distance_weight, dim=3, keepdim=True)[0].expand(\n (-1, -1, -1, mat.shape[3])\n )\n mat = torch.cat([mat, mp2], dim=1)\n mat = F.relu(self.fc3(mat)) * distance_weight\n # mat = torch.sigmoid(self.fc3(mat)) * distance_weight\n else:\n pts = self.fixed_normalization(pts)\n\n # feature weighting matrix estimation\n if pts.shape[3] == 1:\n mat = F.relu(self.fc1(pts))\n else:\n mat = F.relu(self.bn1(self.fc1(pts)))\n mp1 = torch.max(mat, dim=3, keepdim=True)[0].expand(\n (-1, -1, -1, mat.shape[3])\n )\n mat = torch.cat([mat, mp1], dim=1)\n if pts.shape[3] == 1:\n mat = F.relu(self.fc2(mat))\n else:\n mat = F.relu(self.bn2(self.fc2(mat)))\n mp2 = torch.max(mat, dim=3, keepdim=True)[0].expand(\n (-1, -1, -1, mat.shape[3])\n )\n mat = torch.cat([mat, mp2], dim=1)\n mat = F.relu(self.fc3(mat))\n\n # compute features\n features = torch.matmul(\n x.transpose(1, 2), mat.permute(0, 2, 3, 1)\n ).transpose(1, 2)\n features = self.cv(features).squeeze(3)\n\n return features\n\n" ]

[ [ "torch.sigmoid", "torch.max", "torch.Tensor", "torch.cat", "torch.nn.Conv2d", "torch.nn.init.ones_", "torch.nn.InstanceNorm2d" ] ]

vyk1/YAFS

[ "514f8362c90923fa28f871fcf179b755a9315c47" ]

[ "src/examples/VRGameFog-IFogSim-WL/testConvergence.py" ]

[ "#!/usr/bin/env python2\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Thu Sep 6 16:48:57 2018\n\n@author: isaaclera\n\"\"\"\n\nimport numpy as np\n\nYFAS4 = [11.270442,\n11.270623,\n11.270012,\n11.270021,\n11.270031,\n11.269538,\n11.269547,\n11.268429,\n11.270591,\n11.269940,\n11.268374,\n11.270021,\n11.268418,\n11.268944,\n11.268985,\n11.269444,\n11.270576,\n11.270090,\n11.268944,\n11.269489,\n11.269405,\n11.268916,\n11.269418,\n11.270576,\n11.268837,\n11.269988,\n11.268969,\n11.270012,\n11.269471,\n11.270623,\n11.269921,\n11.269926,\n11.270655,\n11.269552,\n11.269983,\n11.270422,\n11.269480,\n11.268385,\n11.270002,\n11.269427,\n11.270660,\n11.270036,\n11.269861,\n11.270591,\n11.268504,\n11.270493,\n11.269964,\n11.269488,\n11.270031,\n11.270581]\n\nYAFS8 = [11.265525,\n11.266339,\n11.266815,\n11.266855,\n11.266066,\n11.266793,\n11.266837,\n11.266059,\n11.266313,\n11.266814,\n11.266597,\n11.266853,\n11.266819,\n11.266840,\n11.266598,\n11.266553,\n11.266891,\n11.266056,\n11.266781,\n11.266583,\n11.266566,\n11.266300,\n11.266042,\n11.266070,\n11.266315,\n11.266567,\n11.266575,\n11.266032,\n11.266579,\n11.266357,\n11.266556,\n11.266026,\n11.266585,\n11.266874,\n11.266852,\n11.266317,\n11.266556,\n11.266585,\n11.266068,\n11.266295,\n11.266595,\n11.266322,\n11.266562,\n11.266813,\n11.266328,\n11.266572,\n11.266858,\n11.266055,\n11.266320,\n11.266334]\n\nYAFS12 = [11.265424,\n11.265598,\n11.265620,\n11.265262,\n11.265421,\n11.265447,\n11.265605,\n11.265604,\n11.265599,\n11.265603,\n11.265615,\n11.265617,\n11.265598,\n11.265611,\n11.265435,\n11.265603,\n11.265604,\n11.264904,\n11.265612,\n11.265434,\n11.265609,\n11.265102,\n11.265423,\n11.265266,\n11.265425,\n11.265250,\n11.265427,\n11.265452,\n11.265432,\n11.265456,\n11.265073,\n11.265626,\n11.265082,\n11.265417,\n11.265081,\n11.265090,\n11.265265,\n11.265614,\n11.265094,\n11.265259,\n11.265436,\n11.265610,\n11.265619,\n11.265598,\n11.265281,\n11.265595,\n11.265083,\n11.265441,\n11.265621,\n11.265591]\n\nYAFS16 =[11.264981,\n11.264608,\n11.264860,\n11.264854,\n11.264883,\n11.264875,\n11.264857,\n11.264865,\n11.264863,\n11.264857,\n11.264860,\n11.264999,\n11.264733,\n11.264727,\n11.264738,\n11.264731,\n11.264991,\n11.264994,\n11.264860,\n11.264999,\n11.265000,\n11.264991,\n11.264983,\n11.264748,\n11.264866,\n11.264988,\n11.264999,\n11.264995,\n11.265004,\n11.264867,\n11.264997,\n11.264882,\n11.264995,\n11.264859,\n11.264741,\n11.264730,\n11.264740,\n11.264865,\n11.264717,\n11.264725,\n11.264734,\n11.264207,\n11.264864,\n11.264866,\n11.264613,\n11.264729,\n11.264743,\n11.264859,\n11.264850,\n11.264727]\n\niFOG4 = [31.567014877440677,\n31.2096085700963,\n31.572940602513007,\n32.09846731216869,\n31.792375613564243,\n31.424621004232844,\n32.04335456925575,\n31.64746479672535,\n31.864294659944616,\n31.953031858836283,\n31.494672286834362,\n31.39366324536594,\n31.9330291330959,\n31.624966442944583,\n31.351483395614157,\n31.360150842367922,\n31.946874707666186,\n31.46681646446987,\n31.725400313292727,\n31.878630822078588,\n31.450552934872057,\n31.561696751665966,\n31.760980953726737,\n31.61584410211693,\n31.85765037646526,\n31.588118685691732,\n31.538965103047765,\n31.875204878212468,\n32.04039882134873,\n31.974034757361743,\n31.825800952238026,\n31.860045585250894,\n31.74689429856358,\n31.595326959974482,\n31.567728517075153,\n31.67316165064918,\n31.734033481104987,\n31.747852362825974,\n31.697831781669656,\n31.449777335693597,\n31.633845469419953,\n31.261946244207035,\n31.512462484441933,\n31.738540845661536,\n31.829588718812303,\n31.61758201414952,\n31.755117403160344,\n31.684510700310877,\n31.663332103705088,\n31.59112414160327,\n31.736744614282188]\n\niFOG8 = [31.824870005152544,\n31.308233878305664,\n31.63140903918994,\n31.607322598441506,\n31.797154459140017,\n31.60744992813196,\n31.78501672169974,\n31.313537275709574,\n31.556893939936433,\n31.813897687958356,\n31.546548077781956,\n31.54571365545189,\n31.7610100755262,\n31.657092962150408,\n31.811162052815273,\n31.87786253393602,\n31.733055897530978,\n31.66802107358438,\n31.86733314438995,\n31.60201939019151,\n31.856532456020354,\n31.593935385166244,\n31.91018849931251,\n31.741217704968758,\n31.71168869299696,\n31.68676569379744,\n31.654600237926505,\n31.634309962315537,\n31.78376537464453,\n31.523910842992237,\n31.344856954660475,\n31.802250975942954,\n31.49838544019412,\n31.71671805331793,\n31.681395720312402,\n31.873480122111538,\n31.842035466656807,\n31.60424413680737,\n31.677882323684667,\n31.60865151246418,\n31.605794410152583,\n31.7091690924313,\n31.586701523045587,\n31.67643022244788,\n31.65827077853141,\n31.51779854040955]\n\niFOG12 = [31.527656135037645,\n31.566542875429953,\n31.583142226513335,\n31.7183597304816,\n31.617750133241476,\n31.885462498982793,\n31.539747456559475,\n31.657806149276933,\n31.65879173721966,\n31.60788495755312,\n31.75726587500943,\n31.712496136707237,\n31.499593245681424,\n31.508957387495002,\n31.761966259831276,\n31.698547661932345,\n31.801609867084004,\n31.6381053991471,\n31.6363948406526,\n31.67585787825071,\n31.66730693446405,\n31.68694412821118,\n31.804783015645324,\n31.597311537070794,\n31.57325161001325,\n31.587005485736235,\n31.757460511381755,\n31.693234605929035,\n31.674055061553943,\n31.64761152308104,\n31.54117279204224,\n31.54233248362793,\n31.569759110769073,\n31.486255820595197,\n31.609553939297612,\n31.85137358126173,\n32.01635987575208,\n31.65992722412061,\n31.593333594011373,\n31.692828648641054,\n31.71146206016865,\n31.38862252584211,\n31.897913580557333,\n31.830566331867267,\n31.426588863591125,\n31.63415020297928]\n\niFOG16 = [31.44319878979343,\n31.552334454736133,\n31.682084871564953,\n31.761914523261304,\n31.810926207188768,\n31.561097434192455,\n31.779844957414298,\n31.392378353361043,\n31.873843235026225,\n31.744376676391745,\n31.625968801049037,\n31.602215698677004,\n31.813225776124753,\n31.562337244472484,\n31.696847808168243,\n31.903286751887627,\n31.519814582748293,\n31.54366633216892,\n31.58841433840935,\n31.4630381792411,\n31.874078090902373,\n31.690547620132648,\n31.59378772837774,\n31.612639941031595,\n31.568692958222847,\n31.532164860225638,\n31.726651022826655,\n31.802570700370133,\n31.735676103172228,\n31.6413832499989,\n31.59990847806666,\n31.5974415806301,\n31.592421292125856,\n31.700416447580768,\n31.76237040195895,\n31.669176402727306,\n31.741612269184262,\n31.772092793236496,\n31.49199967976739,\n31.88103118845454,\n31.57354311237185,\n31.478132563277104,\n31.847975187719452,\n31.57405712508705,\n31.810763820819652,\n31.55968399736258]\n\nttt = np.array(iFOG16)\nfrom scipy import stats\nprint(stats.describe(ttt))" ]

[ [ "numpy.array", "scipy.stats.describe" ] ]

jm-begon/globally-induced-forest

[ "bf41640a5f0d9db637877dfa077b1d529539dbc6" ]

[ "gif/datasets/setup.py" ]

[ "import os\n\nimport numpy\nfrom numpy.distutils.misc_util import Configuration\n\n\ndef configuration(parent_package=\"\", top_path=None):\n config = Configuration(\"datasets\", parent_package, top_path)\n\n return config\n\nif __name__ == \"__main__\":\n from numpy.distutils.core import setup\n setup(**configuration().todict())\n" ]

[ [ "numpy.distutils.misc_util.Configuration" ] ]

Zhanghaotian1/SDE_conf

[ "90773e807ab8ccdc1963e113a2c72df16b8899c1" ]

[ "SDE_CG_C/utils/evaluation.py" ]

[ "import numpy as np\nfrom tqdm.auto import tqdm\n\nimport torch\nfrom torch_geometric.data import Data\nfrom rdkit import Chem\nfrom rdkit.Chem.rdForceFieldHelpers import MMFFOptimizeMolecule\n\nfrom SDE_CG import utils\n\n\ndef get_rmsd_confusion_matrix(data: Data, useFF=False):\n data.pos_ref = data.pos_ref.view(-1, data.num_nodes, 3)\n data.pos_gen = data.pos_gen.view(-1, data.num_nodes, 3)\n num_gen = data.pos_gen.size(0)\n num_ref = data.pos_ref.size(0)\n\n assert num_gen == data.num_pos_gen.item()\n assert num_ref == data.num_pos_ref.item()\n\n rmsd_confusion_mat = -1 * np.ones([num_ref, num_gen],dtype=np.float)\n \n for i in range(num_gen):\n gen_mol = utils.set_rdmol_positions(data.rdmol, data.pos_gen[i])\n if useFF:\n #print('Applying FF on generated molecules...')\n MMFFOptimizeMolecule(gen_mol)\n for j in range(num_ref):\n ref_mol = utils.set_rdmol_positions(data.rdmol, data.pos_ref[j])\n \n rmsd_confusion_mat[j,i] = utils.GetBestRMSD(gen_mol, ref_mol)\n\n return rmsd_confusion_mat\n \n\ndef evaluate_conf(data: Data, useFF=False, threshold=0.5):\n rmsd_confusion_mat = get_rmsd_confusion_matrix(data, useFF=useFF)\n rmsd_ref_min = rmsd_confusion_mat.min(-1)\n return (rmsd_ref_min<=threshold).mean(), rmsd_ref_min.mean()\n\n\ndef evaluate_distance(data: Data, ignore_H=True):\n data.pos_ref = data.pos_ref.view(-1, data.num_nodes, 3) # (N, num_node, 3)\n data.pos_gen = data.pos_gen.view(-1, data.num_nodes, 3) # (M, num_node, 3)\n num_ref = data.pos_ref.size(0) # N\n num_gen = data.pos_gen.size(0) # M\n assert num_gen == data.num_pos_gen.item()\n assert num_ref == data.num_pos_ref.item()\n smiles = data.smiles\n\n edge_index = data.edge_index\n atom_type = data.atom_type\n\n # compute generated length and ref length \n ref_lengths = (data.pos_ref[:, edge_index[0]] - data.pos_ref[:, edge_index[1]]).norm(dim=-1) # (N, num_edge)\n gen_lengths = (data.pos_gen[:, edge_index[0]] - data.pos_gen[:, edge_index[1]]).norm(dim=-1) # (M, num_edge)\n # print(ref_lengths.size(), gen_lengths.size())\n #print(ref_lengths.size())\n #print(gen_lengths.size())\n\n stats_single = []\n first = 1\n for i, (row, col) in enumerate(tqdm(edge_index.t())):\n if row >= col: \n continue\n if ignore_H and 1 in (atom_type[row].item(), atom_type[col].item()): \n continue\n gen_l = gen_lengths[:, i]\n ref_l = ref_lengths[:, i]\n if first:\n print(gen_l.size(), ref_l.size())\n first = 0\n mmd = compute_mmd(gen_l.view(-1, 1).cuda(), ref_l.view(-1, 1).cuda()).item()\n stats_single.append({\n 'edge_id': i,\n 'elems': '%s - %s' % (utils.get_atom_symbol(atom_type[row].item()), utils.get_atom_symbol(atom_type[col].item())),\n 'nodes': (row.item(), col.item()),\n 'gen_lengths': gen_l.cpu(),\n 'ref_lengths': ref_l.cpu(),\n 'mmd': mmd\n })\n\n first = 1\n stats_pair = []\n for i, (row_i, col_i) in enumerate(tqdm(edge_index.t())):\n if row_i >= col_i: \n continue\n if ignore_H and 1 in (atom_type[row_i].item(), atom_type[col_i].item()): \n continue\n for j, (row_j, col_j) in enumerate(edge_index.t()):\n if (row_i >= row_j) or (row_j >= col_j): \n continue\n if ignore_H and 1 in (atom_type[row_j].item(), atom_type[col_j].item()): \n continue\n\n gen_L = gen_lengths[:, (i,j)] # (N, 2)\n ref_L = ref_lengths[:, (i,j)] # (M, 2)\n if first:\n # print(gen_L.size(), ref_L.size())\n first = 0\n mmd = compute_mmd(gen_L.cuda(), ref_L.cuda()).item()\n\n stats_pair.append({\n 'edge_id': (i, j),\n 'elems': (\n '%s - %s' % (utils.get_atom_symbol(atom_type[row_i].item()), utils.get_atom_symbol(atom_type[col_i].item())), \n '%s - %s' % (utils.get_atom_symbol(atom_type[row_j].item()), utils.get_atom_symbol(atom_type[col_j].item())), \n ),\n 'nodes': (\n (row_i.item(), col_i.item()),\n (row_j.item(), col_j.item()),\n ),\n 'gen_lengths': gen_L.cpu(),\n 'ref_lengths': ref_L.cpu(),\n 'mmd': mmd\n }) \n\n edge_filter = edge_index[0] < edge_index[1]\n if ignore_H:\n for i, (row, col) in enumerate(edge_index.t()): \n if 1 in (atom_type[row].item(), atom_type[col].item()):\n edge_filter[i] = False\n\n gen_L = gen_lengths[:, edge_filter] # (N, Ef)\n ref_L = ref_lengths[:, edge_filter] # (M, Ef)\n # print(gen_L.size(), ref_L.size())\n mmd = compute_mmd(gen_L.cuda(), ref_L.cuda()).item()\n\n stats_all = {\n 'gen_lengths': gen_L.cpu(),\n 'ref_lengths': ref_L.cpu(),\n 'mmd': mmd\n }\n return stats_single, stats_pair, stats_all\n\ndef guassian_kernel(source, target, kernel_mul=2.0, kernel_num=5, fix_sigma=None):\n '''\n Params:\n\t source: n * len(x)\n\t target: m * len(y)\n\tReturn:\n\t\tsum(kernel_val): Sum of various kernel matrices\n '''\n n_samples = int(source.size()[0])+int(target.size()[0])\n total = torch.cat([source, target], dim=0)\n total0 = total.unsqueeze(0).expand(int(total.size(0)), int(total.size(0)), int(total.size(1)))\n total1 = total.unsqueeze(1).expand(int(total.size(0)), int(total.size(0)), int(total.size(1)))\n\n L2_distance = ((total0-total1)**2).sum(2)\n\n if fix_sigma:\n bandwidth = fix_sigma\n else:\n bandwidth = torch.sum(L2_distance.data) / (n_samples**2-n_samples)\n\n bandwidth /= kernel_mul ** (kernel_num // 2)\n bandwidth_list = [bandwidth * (kernel_mul**i) for i in range(kernel_num)]\n\n kernel_val = [torch.exp(-L2_distance / bandwidth_temp) for bandwidth_temp in bandwidth_list]\n\n return sum(kernel_val)#/len(kernel_val)\n \ndef compute_mmd(source, target, kernel_mul=2.0, kernel_num=5, fix_sigma=None):\n '''\n Params:\n\t source: (N, D)\n\t target: (M, D)\n\tReturn:\n\t\tloss: MMD loss\n '''\n batch_size = int(source.size()[0])\n kernels = guassian_kernel(source, target,\n kernel_mul=kernel_mul, kernel_num=kernel_num, fix_sigma=fix_sigma)\n\n XX = kernels[:batch_size, :batch_size]\n YY = kernels[batch_size:, batch_size:]\n XY = kernels[:batch_size, batch_size:]\n YX = kernels[batch_size:, :batch_size]\n loss = torch.mean(XX) + torch.mean(YY) - torch.mean(XY) - torch.mean(YX)\n\n return loss\n\n\n\"\"\"\nAnother implementation:\n https://github.com/martinepalazzo/kernel_methods/blob/master/kernel_methods.py\n\"\"\"" ]

[ [ "torch.mean", "torch.cat", "torch.sum", "numpy.ones", "torch.exp" ] ]

will-jj/arim

[ "fc15efe171a41355090123fcea10406ee75efe31" ]

[ "arim/plot.py" ]

[ "\"\"\"\nPlotting utilities based on `matplotib <http://matplotlib.org/>`_.\n\nSome default values are configurable via the dictionary ``arim.plot.conf``.\n\n.. py:data:: conf\n\n Dictionary of default values. For some functions, if an argument is not populated,\n its values will be populated from this dictionary. Example::\n\n # save the figure (independently on conf['savefig])\n plot_oyz(data, grid, savefig=True, filename='foo')\n\n # do not save the figure independently on conf['savefig])\n plot_oyz(data, grid, savefig=False, filename='foo')\n\n # save the figure depending only if conf['savefig'] is True\n plot_oyz(data, grid, filename='foo')\n\n.. py:data:: micro_formatter\n.. py:data:: milli_formatter\n.. py:data:: mega_formatter\n\n Format the labels of an axis in a given unit prefix. Usage::\n\n import matplotlib.pyplot as plt\n ax = plt.plot(distance_vector, data)\n ax.xaxis.set_major_formatter(arim.plot.milli_formatter)\n\n\"\"\"\n\nfrom warnings import warn\nimport logging\n\nfrom matplotlib import ticker\nfrom mpl_toolkits import axes_grid1\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport scipy.signal\n\nfrom . import ut\nfrom .exceptions import ArimWarning\nfrom . import geometry as g\nfrom .config import Config\n\n__all__ = [\n \"micro_formatter\",\n \"mega_formatter\",\n \"milli_formatter\",\n \"plot_bscan\",\n \"plot_bscan_pulse_echo\",\n \"plot_oxz\",\n \"plot_oxz_many\",\n \"plot_tfm\",\n \"plot_directivity_finite_width_2d\",\n \"draw_rays_on_click\",\n \"RayPlotter\",\n \"conf\",\n \"common_dynamic_db_scale\",\n]\n\nlogger = logging.getLogger(__name__)\n\nmicro_formatter = ticker.FuncFormatter(lambda x, pos: \"{:.1f}\".format(x * 1e6))\nmicro_formatter.__doc__ = \"Format an axis to micro (µ).\\nExample: ``ax.xaxis.set_major_formatter(micro_formatter)``\"\n\nmilli_formatter = ticker.FuncFormatter(lambda x, pos: \"{:.1f}\".format(x * 1e3))\nmilli_formatter.__doc__ = \"Format an axis to milli (m).\\nExample: ``ax.xaxis.set_major_formatter(milli_formatter)``\"\n\nmega_formatter = ticker.FuncFormatter(lambda x, pos: \"{:.1f}\".format(x * 1e-6))\nmega_formatter.__doc__ = \"Format an axis to mega (M).\\nExample: ``ax.xaxis.set_major_formatter(mega_formatter)``\"\n\nconf = Config(\n [\n (\"savefig\", False), # save the figure?\n (\"plot_oxz.figsize\", None),\n (\"plot_oxz_many.figsize\", None),\n ]\n)\n\n\ndef plot_bscan(\n frame,\n timetraces_idx,\n use_dB=True,\n ax=None,\n title=\"B-scan\",\n clim=None,\n interpolation=\"none\",\n draw_cbar=True,\n cmap=None,\n savefig=None,\n filename=\"bscan\",\n):\n \"\"\"Plot Bscan (timetraces vs time)\n \n Parameters\n ----------\n frame : Frame\n timetraces_idx : slice or tuple or ndarray\n timetraces to use. Any valid numpy array is accepted.\n use_dB : bool, optional\n ax : matplotlib axis, optional\n Where to draw. Default: create a new figure and axis.\n title : str, optional\n Title of the image (default: \"Bscan\")\n clim : tuple, optional\n Color limits of the image.\n interpolation : str, optional\n Image interpolation type (default: \"none\")\n draw_cbar : bool, optional\n cmap : str, optional\n savefig : bool, optional\n Default: use ``conf[\"savefig\"]``\n filename : str, optional\n Default: \"bscan\"\n \n Returns\n -------\n ax : matplotlib axis\n im : matplotlib image\n\n Examples\n --------\n\n >>> arim.plot.plot_bscan(frame, frame.tx == 0)\n\n \"\"\"\n if ax is None:\n fig, ax = plt.subplots()\n else:\n fig = ax.figure\n\n if savefig is None:\n savefig = conf[\"savefig\"]\n\n timetraces = frame.timetraces[timetraces_idx]\n numtimetraces = timetraces.shape[0]\n if use_dB:\n timetraces = ut.decibel(timetraces)\n if clim is None:\n clim = [-40.0, 0.0]\n\n im = ax.imshow(\n timetraces,\n extent=[frame.time.start, frame.time.end, 0, numtimetraces - 1],\n interpolation=interpolation,\n cmap=cmap,\n origin=\"lower\",\n )\n ax.set_xlabel(\"Time (µs)\")\n ax.set_ylabel(\"TX/RX index\")\n ax.xaxis.set_major_formatter(micro_formatter)\n ax.xaxis.set_minor_formatter(micro_formatter)\n\n # Use element index instead of timetrace index (may be different)\n tx = frame.tx[timetraces_idx]\n rx = frame.rx[timetraces_idx]\n\n def _y_formatter(i, pos):\n i = int(i)\n try:\n return f\"({tx[i]}, {rx[i]})\"\n except IndexError:\n return \"\"\n\n y_formatter = ticker.FuncFormatter(_y_formatter)\n ax.yaxis.set_major_formatter(y_formatter)\n ax.yaxis.set_minor_formatter(y_formatter)\n\n if draw_cbar:\n fig.colorbar(im, ax=ax)\n if clim is not None:\n im.set_clim(clim)\n if title is not None:\n ax.set_title(title)\n\n ax.axis(\"tight\")\n if savefig:\n ax.figure.savefig(filename)\n return ax, im\n\n\ndef plot_bscan_pulse_echo(\n frame,\n use_dB=True,\n ax=None,\n title=\"B-scan (pulse-echo)\",\n clim=None,\n interpolation=\"none\",\n draw_cbar=True,\n cmap=None,\n savefig=None,\n filename=\"bscan\",\n):\n \"\"\"\n Plot a B-scan. Use the pulse-echo timetraces.\n\n Parameters\n ----------\n frame\n use_dB\n ax\n title\n clim\n interpolation\n draw_cbar\n cmap\n\n Returns\n -------\n axis, image\n\n See Also\n --------\n :func:`plot_bscan`\n\n \"\"\"\n pulse_echo = frame.tx == frame.rx\n elements = frame.tx[pulse_echo]\n ax, im = plot_bscan(\n frame,\n pulse_echo,\n use_dB=use_dB,\n ax=ax,\n title=title,\n clim=clim,\n interpolation=interpolation,\n draw_cbar=draw_cbar,\n cmap=cmap,\n savefig=False, # save later\n filename=filename,\n )\n ax.set_ylabel(\"Element\")\n # Use element index instead of timetrace index (may be different)\n def _y_formatter(i, pos):\n i = int(i)\n if i >= len(elements):\n return \"\"\n else:\n return str(elements[i])\n\n y_formatter = ticker.FuncFormatter(_y_formatter)\n ax.yaxis.set_major_formatter(y_formatter)\n ax.yaxis.set_minor_formatter(y_formatter)\n\n if savefig:\n ax.figure.savefig(filename)\n\n return ax, im\n\n\ndef plot_psd(\n frame,\n idx=\"all\",\n to_show=\"filtered\",\n welch_params=None,\n ax=None,\n title=\"Power spectrum estimation\",\n show_legend=True,\n savefig=None,\n filename=\"psd\",\n):\n \"\"\"\n Plot the estimated power spectrum of a timetrace using Welch's method.\n\n Parameters\n ----------\n frame : Frame\n idx : int or slice or list\n Index or indices of the timetrace to use. If multiple indices are given,\n the arithmetical mean of all PSDs is plotted. Default: use all\n to_show\n welch_params : dict\n Arguments to pass to ``scipy.signal.welch``.\n ax : matplotlib.axes.Axes or None\n title\n show_legend\n savefig\n filename\n\n Returns\n -------\n ax : matplotlib.axes.Axes\n lines : dict\n\n \"\"\"\n if ax is None:\n fig, ax = plt.subplots()\n else:\n fig = ax.figure\n\n if welch_params is None:\n welch_params = {}\n\n if savefig is None:\n savefig = conf[\"savefig\"]\n\n if isinstance(idx, str) and idx == \"all\":\n idx = slice(None)\n\n fs = 1 / frame.time.step\n\n to_show = to_show.lower()\n if to_show == \"both\":\n show_raw = True\n show_filtered = True\n elif to_show == \"raw\":\n show_raw = True\n show_filtered = False\n elif to_show == \"filtered\":\n show_raw = False\n show_filtered = True\n else:\n raise ValueError(\"Valid values for 'to_show' are: filtered, raw, both\")\n\n lines = {}\n\n if show_raw:\n x = frame.timetraces_raw[idx].real\n freq, pxx = scipy.signal.welch(x, fs, **welch_params)\n if pxx.ndim == 2:\n pxx = np.mean(pxx, axis=0)\n line = ax.plot(freq, pxx, label=\"raw\".format(idx=idx))\n lines[\"raw\"] = line\n if show_filtered:\n x = frame.timetraces[idx].real\n freq, pxx = scipy.signal.welch(x, fs, **welch_params)\n if pxx.ndim == 2:\n pxx = np.mean(pxx, axis=0)\n line = ax.plot(freq, pxx, label=\"filtered\".format(idx=idx))\n lines[\"filtered\"] = line\n ax.set_xlabel(\"frequency (MHz)\")\n ax.set_ylabel(\"power spectrum estimation\")\n ax.xaxis.set_major_formatter(mega_formatter)\n ax.xaxis.set_minor_formatter(mega_formatter)\n\n if title is not None:\n ax.set_title(title)\n\n if show_legend:\n ax.legend(loc=\"best\")\n\n if savefig:\n fig.savefig(filename)\n return ax, lines\n\n\ndef plot_oxz(\n data,\n grid,\n ax=None,\n title=None,\n clim=None,\n interpolation=\"none\",\n draw_cbar=True,\n cmap=None,\n figsize=None,\n savefig=None,\n patches=None,\n filename=None,\n scale=\"linear\",\n ref_db=None,\n):\n \"\"\"\n Plot data in the plane Oxz.\n\n Parameters\n ----------\n data : ndarray\n Shape: 2D matrix ``(grid.numx, grid.numz)`` or 3D matrix ``(grid.numx, 1, grid.numz)``\n or 1D matrix ``(grid.numx * grid.numz)``\n grid : Grid\n ax : matplotlib.Axis or None\n Axis where to plot.\n title : str or None\n clim : List[Float] or None\n interpolation : str or None\n draw_cbar : boolean\n cmap\n figsize : List[Float] or None\n Default: ``conf['plot_oxz.figsize']``\n savefig : boolean or None\n If True, save the figure. Default: ``conf['savefig']``\n patches : List[matplotlib.patches.Patch] or None\n Patches to draw\n filename : str or None\n If True\n scale : str or None\n 'linear' or 'db'. Default: 'linear'\n ref_db : float or None\n Value for 0 dB. Used only for scale=db.\n\n Returns\n -------\n axis\n image\n\n Examples\n --------\n ::\n\n grid = arim.geometry.Grid(-5e-3, 5e-3, 0, 0, 0, 15e-3, .1e-3)\n k = 2 * np.pi / 10e-3\n data = (np.cos(grid.x * 2 * k) * np.sin(grid.z * k))\n ax, im = aplt.plot_oxz(data, grid)\n\n\n \"\"\"\n if figsize is None:\n figsize = conf[\"plot_oxz.figsize\"]\n else:\n if ax is not None:\n warn(\n \"figsize is ignored because an axis is provided\",\n ArimWarning,\n stacklevel=2,\n )\n if savefig is None:\n savefig = conf[\"savefig\"]\n\n if ax is None:\n fig, ax = plt.subplots(figsize=figsize)\n else:\n fig = ax.figure\n if patches is None:\n patches = []\n\n valid_shapes = [\n (grid.numx, 1, grid.numz),\n (grid.numx, grid.numz),\n (grid.numx * grid.numz,),\n ]\n if data.shape in valid_shapes:\n data = data.reshape((grid.numx, grid.numz))\n else:\n msg = \"invalid data shape (got {}, expected {} or {} or {})\".format(\n data.shape, *valid_shapes\n )\n raise ValueError(msg)\n\n data = np.rot90(data)\n\n scale = scale.lower()\n if scale == \"linear\":\n if ref_db is not None:\n warn(\"ref_db is ignored for linear plot\", ArimWarning, stacklevel=2)\n elif scale == \"db\":\n data = ut.decibel(data, ref_db)\n else:\n raise ValueError(\"invalid scale: {}\".format(scale))\n\n image = ax.imshow(\n data,\n interpolation=interpolation,\n origin=\"lower\",\n extent=(grid.xmin, grid.xmax, grid.zmax, grid.zmin),\n cmap=cmap,\n )\n if ax.get_xlabel() == \"\":\n # avoid overwriting labels\n ax.set_xlabel(\"x (mm)\")\n if ax.get_ylabel() == \"\":\n ax.set_ylabel(\"z (mm)\")\n ax.xaxis.set_major_formatter(milli_formatter)\n ax.xaxis.set_minor_formatter(milli_formatter)\n ax.yaxis.set_major_formatter(milli_formatter)\n ax.yaxis.set_minor_formatter(milli_formatter)\n if draw_cbar:\n # necessary magic to make the colorbar the same height as the image\n divider = axes_grid1.make_axes_locatable(ax)\n cax = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n cax.set_aspect(aspect=20, adjustable=\"box\")\n fig.colorbar(image, ax=ax, cax=cax)\n if clim is not None:\n image.set_clim(clim)\n if title is not None:\n ax.set_title(title)\n for p in patches:\n ax.add_patch(p)\n\n # Like axis('equal') but mitigates https://github.com/matplotlib/matplotlib/issues/11416\n # adjustable=box to avoid white space (default in matplotlib 3)\n ax.axis(aspect=1, adjustable=\"box\")\n ax.axis([grid.xmin, grid.xmax, grid.zmax, grid.zmin])\n if savefig:\n if filename is None:\n raise ValueError(\"filename must be provided when savefig is true\")\n fig.savefig(filename)\n return ax, image\n\n\ndef plot_oxz_many(\n data_list,\n grid,\n nrows,\n ncols,\n title_list=None,\n suptitle=None,\n draw_colorbar=True,\n figsize=None,\n savefig=None,\n clim=None,\n filename=None,\n y_title=1.0,\n y_suptitle=1.0,\n axes_pad=0.1,\n **plot_oxz_kwargs,\n):\n \"\"\"\n Plot many Oxz plots on the same figure.\n\n Parameters\n ----------\n data_list : List[ndarray]\n Data are plotted from top left to bottom right, row per row.\n grid : Grid\n nrows : int\n ncols : int\n title_list : List[str] or None\n suptitle : str or None\n draw_colorbar : boolean\n Default: True\n figsize : List[Float] or None\n Default: ``conf['plot_oxz_many.figsize']``\n savefig: boolean\n Default: ``conf['savefig']``\n clim :\n Color limit. Common for all plots.\n filename\n y_title : float\n Adjust y location of the titles.\n y_suptitle : float\n Adjust y location of the titles.\n axes_pad : float\n Pad between images in inches\n\n plot_oxz_kwargs\n\n Returns\n -------\n axes_grid : axes_grid1.ImageGrid\n im_list\n\n \"\"\"\n if savefig is None:\n savefig = conf[\"savefig\"]\n if figsize is None:\n figsize = conf[\"plot_oxz_many.figsize\"]\n\n if title_list is None:\n title_list = [None] * len(data_list)\n\n # must use a common clim (otherwise the figure does not make sense)\n if clim is None:\n clim = (\n min(np.nanmin(x) for x in data_list),\n max(np.nanmax(x) for x in data_list),\n )\n\n if draw_colorbar:\n cbar_mode = \"single\"\n else:\n cbar_mode = None\n fig = plt.figure(figsize=figsize)\n axes_grid = axes_grid1.ImageGrid(\n fig,\n 111,\n nrows_ncols=(nrows, ncols),\n axes_pad=axes_pad,\n share_all=True,\n cbar_mode=cbar_mode,\n )\n\n images = []\n for data, title, ax in zip(data_list, title_list, axes_grid):\n # the current function handles saving fig, drawing the cbar and displaying the title\n # so we prevent plot_oxz to do it.\n ax, im = plot_oxz(\n data,\n grid,\n ax=ax,\n clim=clim,\n draw_cbar=False,\n savefig=False,\n **plot_oxz_kwargs,\n title=None,\n )\n images.append(im)\n if title is not None:\n ax.set_title(title, y=y_title)\n if suptitle is not None:\n fig.suptitle(suptitle, y=y_suptitle, size=\"x-large\")\n if draw_colorbar:\n cax = axes_grid.cbar_axes[0]\n fig.colorbar(im, cax=cax)\n cax.set_aspect(20, adjustable=\"box\")\n if savefig:\n if filename is None:\n raise ValueError(\"filename must be provided when savefig is true\")\n fig.savefig(filename)\n return axes_grid, images\n\n\ndef plot_tfm(tfm, y=0.0, func_res=None, interpolation=\"bilinear\", **plot_oxz_kwargs):\n \"\"\"\n Plot a TFM in plane Oxz.\n\n Parameters\n ----------\n tfm : BaseTFM\n y : float\n interpolation : str\n Cf matplotlib.pyplot.imshow\n func_res : function\n Function to apply on tfm.res before plotting it. Example: ``lambda x: np.abs(x)``\n plot_oxz_kwargs : dict\n\n Returns\n -------\n ax\n image\n\n See Also\n --------\n :func:`plot_oxz`\n\n \"\"\"\n grid = tfm.grid\n iy = np.argmin(np.abs(grid.y - y))\n\n if tfm.res is None:\n raise ValueError(\"No result in this TFM object.\")\n if func_res is None:\n func_res = lambda x: x\n\n data = func_res(tfm.res[:, iy, :])\n\n return plot_oxz(data, grid=grid, interpolation=interpolation, **plot_oxz_kwargs)\n\n\ndef plot_directivity_finite_width_2d(element_width, wavelength, ax=None, **kwargs):\n \"\"\"\n\n Parameters\n ----------\n element_width\n wavelength\n ax : matplotlib.axes._subplots.AxesSubplot\n kwargs\n\n Returns\n -------\n\n \"\"\"\n if ax is None:\n fig, ax = plt.subplots()\n else:\n fig = ax.figure\n\n title = kwargs.get(\n \"title\", \"Directivity of an element (uniform sources along a straight line)\"\n )\n\n ratio = element_width / wavelength\n theta = np.linspace(-np.pi / 2, np.pi / 2, 100)\n directivity = ut.directivity_finite_width_2d(theta, element_width, wavelength)\n\n ax.plot(\n np.rad2deg(theta),\n directivity,\n label=r\"$a/\\lambda = {:.2f}$\".format(ratio),\n **kwargs,\n )\n ax.set_xlabel(r\"Polar angle $\\theta$ (deg)\")\n ax.set_ylabel(\"directivity (1)\")\n ax.set_title(title)\n ax.set_xlim([-90, 90])\n ax.set_ylim([0, 1.2])\n ax.xaxis.set_major_locator(ticker.MultipleLocator(30.0))\n ax.xaxis.set_minor_locator(ticker.MultipleLocator(15.0))\n ax.yaxis.set_minor_locator(ticker.MultipleLocator(0.1))\n ax.legend()\n return ax\n\n\nclass RayPlotter:\n def __init__(\n self, grid, ray, element_index, linestyle=\"m--\", tolerance_distance=1e-3\n ):\n self.grid = grid\n self.ray = ray\n self.element_index = element_index\n self.linestyle = linestyle\n self._lines = []\n self.debug = False\n self.y = 0\n self.tolerance_distance = tolerance_distance\n\n def __call__(self, event):\n logger.debug(\n \"button=%d, x=%d, y=%d, xdata=%f, ydata=%f\"\n % (event.button, event.x, event.y, event.xdata, event.ydata)\n )\n ax = event.canvas.figure.axes[0]\n if event.button == 1:\n self.draw_ray(ax, event.xdata, event.ydata)\n elif event.button == 3:\n self.clear_rays(ax)\n if self.debug:\n print(\"show_ray_on_clic() finish with no error\")\n\n def draw_ray(self, ax, x, z):\n gridpoints = self.grid.to_1d_points()\n wanted_point = (x, self.y, z)\n point_index = gridpoints.closest_point(*wanted_point)\n obtained_point = gridpoints[point_index]\n\n distance = g.norm2(*(obtained_point - wanted_point))\n if distance > self.tolerance_distance:\n logger.warning(\n \"The closest grid point is far from what you want (dist: {:.2f} mm)\".format(\n distance * 1000\n )\n )\n\n legs = self.ray.get_coordinates_one(self.element_index, point_index)\n line = ax.plot(legs.x, legs.z, self.linestyle)\n self._lines.extend(line)\n logger.debug(\"Draw a ray\")\n ax.figure.canvas.draw_idle()\n\n def clear_rays(self, ax):\n \"\"\"Clear all rays\"\"\"\n lines_to_clear = [line for line in ax.lines if line in self._lines]\n for line in lines_to_clear:\n ax.lines.remove(line)\n self._lines.remove(line)\n logger.debug(\"Clear {} ray(s) on figure\".format(len(lines_to_clear)))\n ax.figure.canvas.draw_idle()\n\n def connect(self, ax):\n \"\"\"Connect to matplotlib event backend\"\"\"\n ax.figure.canvas.mpl_connect(\"button_press_event\", self)\n\n\ndef draw_rays_on_click(grid, ray, element_index, ax=None, linestyle=\"m--\"):\n \"\"\"\n Dynamic plotting of rays on a plot.\n\n Left-click: draw a ray between the probe element and the mouse point.\n Right-click: clear all rays in the plot.\n\n Parameters\n ----------\n grid : Grid\n ray : Rays\n\n element_index : int\n ax : Axis\n Matplotlib axis on which to plot. If None: current axis.\n linestyle : str\n A valid matplotlib linestyle. Default: 'm--'\n\n Returns\n -------\n ray_plotter : RayPlotter\n\n \"\"\"\n if ax is None:\n ax = plt.gca()\n ray_plotter = RayPlotter(\n grid=grid, ray=ray, element_index=element_index, linestyle=linestyle\n )\n ray_plotter.connect(ax)\n return ray_plotter\n\n\ndef plot_interfaces(\n oriented_points_list,\n ax=None,\n show_probe=True,\n show_last=True,\n show_orientations=False,\n n_arrows=10,\n title=\"Interfaces\",\n savefig=None,\n filename=\"interfaces\",\n markers=None,\n show_legend=True,\n quiver_kwargs=None,\n):\n \"\"\"\n Plot interfaces on the Oxz plane.\n\n Assume the first interface is for the probe and the last is for the grid.\n\n Parameters\n ----------\n oriented_points_list : list[OrientedPoints]\n ax : matplotlib.axis.Axis\n show_probe : boolean\n Default True\n show_last : boolean\n Default: True. Useful for hiding the grid.\n show_orientations : boolean\n Plot arrows for the orientations. Default: False\n n_arrows : int\n Number of arrows per interface to plot.\n title : str or None\n Title to display. None for no title.\n savefig : boolean\n If True, the plot will be saved. Default: ``conf['savefig']``.\n filename : str\n Filename of the plot, used if savefig is True. Default: 'interfaces'\n markers : List[str]\n Matplotlib markers for each interfaces. Default: '.' for probe, ',k' for the grid,\n '.' for the rest.\n show_legend : boolean\n Default True\n quiver_kwargs : dict\n Arguments for displaying the arrows (cf. matplotlib function 'quiver')\n\n Returns\n -------\n ax : matplotlib.axis.Axis\n\n \"\"\"\n if savefig is None:\n savefig = conf[\"savefig\"]\n\n if ax is None:\n fig, ax = plt.subplots()\n else:\n fig = ax.figure\n\n if quiver_kwargs is None:\n quiver_kwargs = dict(width=0.0003)\n\n numinterfaces = len(oriented_points_list)\n\n if markers is None:\n markers = [\".\"] + [\".\"] * (numinterfaces - 2) + [\",k\"]\n\n for i, (interface, marker) in enumerate(zip(oriented_points_list, markers)):\n if i == 0 and not show_probe:\n continue\n if i == numinterfaces - 1 and not show_last:\n continue\n (line,) = ax.plot(\n interface.points.x, interface.points.z, marker, label=interface.points.name\n )\n\n if show_orientations:\n # arrow every k points\n k = len(interface.points) // n_arrows\n if k == 0:\n k = 1\n # import pytest; pytest.set_trace()\n ax.quiver(\n interface.points.x[::k],\n interface.points.z[::k],\n interface.orientations.x[::k, 2],\n interface.orientations.z[::k, 2],\n color=line.get_color(),\n units=\"xy\",\n angles=\"xy\",\n **quiver_kwargs,\n )\n\n # set labels only if there is none in the axis yet\n if ax.get_xlabel() == \"\":\n ax.set_xlabel(\"x (mm)\")\n if ax.get_ylabel() == \"\":\n ax.set_ylabel(\"z (mm)\")\n\n ax.xaxis.set_major_formatter(milli_formatter)\n ax.yaxis.set_major_formatter(milli_formatter)\n ax.xaxis.set_minor_formatter(milli_formatter)\n ax.yaxis.set_minor_formatter(milli_formatter)\n\n if title is not None:\n ax.set_title(title)\n\n ylim = ax.get_ylim()\n if ylim[0] < ylim[1]:\n ax.invert_yaxis()\n\n if show_legend:\n ax.legend(loc=\"best\")\n\n ax.axis(\"equal\")\n\n if savefig:\n fig.savefig(filename)\n return ax\n\n\ndef common_dynamic_db_scale(data_list, area=None, db_range=40.0, ref_db=None):\n \"\"\"\n Scale such as:\n - 0 dB corresponds to the maximum value in the area for all data arrays,\n - the clim for each data array are bound by the maximum value in the area.\n\n Parameters\n ----------\n data_list\n db_range : float\n\n Yields\n ------\n ref_db\n (clim_min, clim_max)\n\n Examples\n --------\n\n >>> area = grid.points_in_rectbox(xmin=10, xmax=20)\n >>> common_db_scale_iter = common_dynamic_db_scale(data_list, area)\n >>> for data in data_list:\n ... ref_db, clim = next(common_db_scale_iter)\n ... plot_oxz(data, grid, scale='db', ref_db=ref_db, clim=clim)\n\n \"\"\"\n data_max_list = []\n\n if area is None:\n area = slice(None)\n\n for data in data_list:\n data_max_list.append(np.nanmax(np.abs(data[area])))\n if ref_db is None:\n ref_db = max(data_max_list)\n\n data_max_db_list = ut.decibel(data_max_list, ref_db)\n\n for data_max_db in data_max_db_list:\n yield ref_db, (data_max_db - db_range, data_max_db)\n" ]

[ [ "numpy.nanmax", "numpy.rot90", "matplotlib.ticker.MultipleLocator", "matplotlib.pyplot.gca", "numpy.abs", "numpy.linspace", "numpy.nanmin", "matplotlib.pyplot.subplots", "numpy.rad2deg", "numpy.mean", "matplotlib.ticker.FuncFormatter", "matplotlib.pyplot.figure" ] ]

tanfei2007/DeepM6A

[ "ac8b5543db292516ce10cf42b7506004140d4d41", "ac8b5543db292516ce10cf42b7506004140d4d41" ]

[ "Motif_Analysis/Code/optimizer.py", "Code/TSNE/t_SNE_testing_data.py" ]

[ "#*********************\n# Fei Tan\n# [email protected]\n# March 28, 2017\n#********************\n\n\nimport numpy as np\nimport pprint\n\nfrom keras import backend as K\nfrom collections import OrderedDict\n\nclass Optimizer(object):\n\t\n\tdef __init__(self, seq_input, losses, wrt=None):\n\n\t\tself.seq = seq_input\n\t\tself.loss_functions = []\n\t\tself.wrt = self.seq if wrt is None else wrt\n\n\t\toverall_loss = K.variable(0.)\n\n\t\tfor loss, weight in losses:\n\t\t\tif weight != 0:\n\t\t\t\tloss_fn = weight * loss.build_loss()\n\t\t\t\toverall_loss += loss_fn\n\t\t\t\t# learning phase: 0 (test), 1(train)\n\t\t\t\tself.loss_functions.append( ( loss.name, K.function( [self.seq, K.learning_phase()], [loss_fn]) ) )\n\n\t\tgrads = K.gradients(overall_loss, self.wrt)[0]\n\t\tgrads = grads / (K.sqrt(K.mean(K.square(grads))) + K.epsilon())\n\n\t\tself.overall_loss_grad_wrt_fn = K.function([self.seq, K.learning_phase()], [overall_loss, grads, self.wrt])\n\t\t\n\t\n\tdef eval_losses(self, seq):\n\n\t\tlosses = OrderedDict()\n\t\tfor name, fn in self.loss_functions:\n\t\t\tlosses[name] = fn([seq, 0])\n\t\treturn losses\n\n\tdef rmsprop(self, grads, cache=None, decay_rate=0.95):\n\t\tif cache is None:\n\t\t\tcache = np.zeros_like(grads)\n\t\tcache = decay_rate * cache + (1 - decay_rate) * (grads ** 2)\n\t\tstep = -grads / np.sqrt(cache + K.epsilon())\n\t\treturn step, cache\n\n\tdef get_seed_seq(self, seed_seq):\n\t\tsample_size, filter_length, nucleotide_size = self.seq._keras_shape\n\t\tprint(filter_length, nucleotide_size)\n\t\tif seed_seq is None:\n\t\t\tseed_seq = np.ones((filter_length, nucleotide_size))/4.\n\n\t\tseed_seq = np.array([seed_seq], dtype=np.float32)\n\n\t\treturn seed_seq\n\n\n\tdef minimize(self, seed_seq=None, max_iter=200, lr = 0.1, verbose=True):\n\t\t\"\"\"Performs gradient descent on the input sequenc with respect to defined losses\"\"\"\n\t\t\n\t\tseed_seq = self.get_seed_seq(seed_seq)\n\t\tcache = None\n\t\tbest_loss = float('inf')\n\t\tbest_seq = None\n\n\t\tgrads = None\n\n\t\t\n\t\tfor i in range(max_iter):\n\t\t\toverall_loss, grads, wrt_value = self.overall_loss_grad_wrt_fn([seed_seq, 0])\n\n\t\t\tif verbose:\n\t\t\t\tlosses = self.eval_losses(seed_seq)\n\t\t\t\tprint('Interation: {}, losses: {}, overall loss: {}'.format(i+1, pprint.pformat(losses), overall_loss))\n\t\n\t\t\t\n\t\t\t#gradient descent update\n\t\t\tif self.wrt is self.seq:\n\t\t\t\tstep, cache = self.rmsprop(grads, cache)\n\t\t\t\t\n\t\t\t\t#to be revised later\n\t\t\t\tseed_seq += lr * step\n\t\t\t\n\t\t\tif overall_loss < best_loss:\n\t\t\t\tbest_loss = overall_loss\n\t\t\t\tbest_seq = seed_seq.copy()\n\n\n\t\treturn best_seq[0], grads, wrt_value\n", "import numpy as np\nimport h5py\nimport pandas as pd\nfrom sklearn.manifold import TSNE\n\n# Read testing data\ntestmat = h5py.File('data/m6A_30.test_1.hdf5', 'r')\nX_test = np.transpose(np.array(testmat['x_train']),axes=(0,2, 1))\ny_test = np.array(testmat['y_train'])\n# Transfer 3-D array to 2-D array\nX_test_array = X_test.reshape((X_test.shape[0], -1), order='F')\n\nfeat_cols = [ 'seq'+str(i) for i in range(X_test_array.shape[1]) ]\n\ndf = pd.DataFrame(X_test_array,columns=feat_cols)\ndf['label'] = y_test\ndf['label'] = df['label'].apply(lambda i: str(i))\n\n# Sample 10000 sequences to plot\nnp.random.seed(1337) # for reproducibility\nn_sne = 10000\nrndperm = np.random.permutation(df.shape[0])\n\n\ntsne = TSNE(n_components=2, verbose=1, perplexity=40, n_iter=300)\ntsne_results = tsne.fit_transform(df.loc[rndperm[:n_sne],feat_cols].values)\n\ndf_tsne = df.loc[rndperm[:n_sne],:].copy()\ndf_tsne['x-tsne'] = tsne_results[:,0]\ndf_tsne['y-tsne'] = tsne_results[:,1]\n\ndf_tsne.to_csv('Raw_test_seq_tsne.csv', index = False)\n" ]

[ [ "numpy.array", "numpy.zeros_like", "numpy.ones" ], [ "numpy.random.seed", "pandas.DataFrame", "sklearn.manifold.TSNE", "numpy.random.permutation", "numpy.array" ] ]

malikasng/Bbox_HGG_with_CTR_and_RRTstarFND

[ "2b1aae6c347f544fefface0c9f26dc4ecde51108" ]

[ "utils/stable_baselines_plotter.py" ]

[ "# from https://github.com/hill-a/stable-baselines/blob/master/stable_baselines/results_plotter.py\nimport numpy as np\nimport matplotlib\nimport matplotlib.pyplot as plt\nimport pandas as pd\n\n# matplotlib.use('TkAgg') # Can change to 'Agg' for non-interactive mode\nplt.rcParams['svg.fonttype'] = 'none'\n\nX_TIMESTEPS = 'timesteps'\nX_EPISODES = 'episodes'\nX_WALLTIME = 'walltime_hrs'\nPOSSIBLE_X_AXES = [X_TIMESTEPS, X_EPISODES, X_WALLTIME]\nCOLORS = ['blue', 'green', 'red', 'cyan', 'magenta', 'yellow', 'black', 'purple', 'pink',\n 'brown', 'orange', 'teal', 'coral', 'lightblue', 'lime', 'lavender', 'turquoise',\n 'darkgreen', 'tan', 'salmon', 'gold', 'lightpurple', 'darkred', 'darkblue']\n\n\ndef rolling_window(array, window):\n \"\"\"\n apply a rolling window to a np.ndarray\n :param array: (np.ndarray) the input Array\n :param window: (int) length of the rolling window\n :return: (np.ndarray) rolling window on the input array\n \"\"\"\n shape = array.shape[:-1] + (array.shape[-1] - window + 1, window)\n strides = array.strides + (array.strides[-1],)\n return np.lib.stride_tricks.as_strided(array, shape=shape, strides=strides)\n\n\ndef window_func(var_1, var_2, window, func):\n \"\"\"\n apply a function to the rolling window of 2 arrays\n :param var_1: (np.ndarray) variable 1\n :param var_2: (np.ndarray) variable 2\n :param window: (int) length of the rolling window\n :param func: (numpy function) function to apply on the rolling window on variable 2 (such as np.mean)\n :return: (np.ndarray, np.ndarray) the rolling output with applied function\n \"\"\"\n var_2_window = rolling_window(var_2, window)\n function_on_var2 = func(var_2_window, axis=-1)\n return var_1[window - 1:], function_on_var2\n\n\n '''def ts2xy(timesteps, xaxis):\n \"\"\"\n Decompose a timesteps variable to x ans ys\n :param timesteps: (Pandas DataFrame) the input data\n :param xaxis: (str) the axis for the x and y output\n (can be X_TIMESTEPS='timesteps', X_EPISODES='episodes' or X_WALLTIME='walltime_hrs')\n :return: (np.ndarray, np.ndarray) the x and y output\n \"\"\"\n if xaxis == X_TIMESTEPS:\n x_var = np.cumsum(timesteps.l.values)\n y_var = timesteps.r.values\n elif xaxis == X_EPISODES:\n x_var = np.arange(len(timesteps))\n y_var = timesteps.r.values\n elif xaxis == X_WALLTIME:\n x_var = timesteps.t.values / 3600.\n y_var = timesteps.r.values\n else:\n raise NotImplementedError\n return x_var, y_var'''\n\n\ndef plot_curves(xy_list, xlabel, ylabel, window=1, labels=None,title=None, filename=None):\n \"\"\"\n plot the curves\n :param xy_list: ([(np.ndarray, np.ndarray)]) the x and y coordinates to plot\n :param x_label: (str) the axis for the x and y output\n (can be X_TIMESTEPS='timesteps', X_EPISODES='episodes' or X_WALLTIME='walltime_hrs')\n :param title: (str) the title of the plot\n \"\"\"\n plt.figure(figsize=(16, 8))\n maxx = max(xy[0][-1] for xy in xy_list)\n minx = 0\n for (i, (x, y)) in enumerate(xy_list):\n color = COLORS[i]\n #plt.scatter(x, y, s=2)\n # Do not plot the smoothed curve at all if the timeseries is shorter than window size.\n if x.shape[0] >= window:\n # Compute and plot rolling mean with window of size EPISODE_WINDOW\n x, y_mean = window_func(x, y, window, np.mean)\n if labels is None:\n plt.plot(x, y_mean, color=color)\n else:\n plt.plot(x, y_mean, color=color, label =labels[i])\n plt.xlim(minx, maxx)\n if title is not None:\n plt.title(title)\n plt.legend(loc=\"upper left\")\n plt.xlabel(xlabel)\n plt.ylabel(ylabel)\n plt.tight_layout()\n if filename is not None:\n plt.savefig(filename)\n\n\n'''def plot_results(dirs, num_timesteps, xaxis, task_name):\n \"\"\"\n plot the results\n :param dirs: ([str]) the save location of the results to plot\n :param num_timesteps: (int or None) only plot the points below this value\n :param xaxis: (str) the axis for the x and y output\n (can be X_TIMESTEPS='timesteps', X_EPISODES='episodes' or X_WALLTIME='walltime_hrs')\n :param task_name: (str) the title of the task to plot\n \"\"\"\n\n tslist = []\n for folder in dirs:\n timesteps = load_results(folder)\n if num_timesteps is not None:\n timesteps = timesteps[timesteps.l.cumsum() <= num_timesteps]\n tslist.append(timesteps)\n xy_list = [ts2xy(timesteps_item, xaxis) for timesteps_item in tslist]\n plot_curves(xy_list, xaxis, task_name)'''\n\n'''def main():\n \"\"\"\n Example usage in jupyter-notebook\n .. code-block:: python\n from stable_baselines import results_plotter\n %matplotlib inline\n results_plotter.plot_results([\"./log\"], 10e6, results_plotter.X_TIMESTEPS, \"Breakout\")\n Here ./log is a directory containing the monitor.csv files\n \"\"\"\n import argparse\n import os\n parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n parser.add_argument('--dirs', help='List of log directories', nargs='*', default=['./log'])\n parser.add_argument('--num_timesteps', type=int, default=int(10e6))\n parser.add_argument('--xaxis', help='Varible on X-axis', default=X_TIMESTEPS)\n parser.add_argument('--task_name', help='Title of plot', default='Breakout')\n args = parser.parse_args()\n args.dirs = [os.path.abspath(folder) for folder in args.dirs]\n plot_results(args.dirs, args.num_timesteps, args.xaxis, args.task_name)\n plt.show()'''\n\ndef tdm_training_plot():\n df = pd.read_csv('../logsdir/csv_logs/2020_07_02_12_18_26tdm_training_log.csv')\n indexes = df.columns.values\n '''df.dropna(subset=[i for i in indexes if i != 'epoch'],\n inplace=True, how='all')#this is just because logger creates empty row after before each epoch'''\n\n epoch_time = df[['epoch', 'time']].groupby(by=['epoch'])\n epoch_time = epoch_time.last()\n y = epoch_time[['time']].values[:, 0]\n x = np.arange(0, len(y))\n plot_curves([(x, y)], 'epoch', 'time needed', title='(mixed)',\n filename='../logsdir/csv_logs/time.png')\n\n epAndEpoch_losses = df[\n ['epoch', 'episode', 'actor_tr_loss', 'critic_tr_loss', 'actor_eval_loss', 'critic_eval_loss']\n ].dropna(subset=['episode']).fillna(0.)\n x = np.arange(0, len(epAndEpoch_losses))\n losses_labels = ['actor_tr_loss', 'critic_tr_loss', 'actor_eval_loss', 'critic_eval_loss']\n xs_ys = [(x, epAndEpoch_losses[[k]].values[:, 0])\n for k in losses_labels]\n plot_curves(xs_ys, 'episode (each 100 timesteps)', 'loss', window=20, title='accumulated loss (mixed)',\n labels=losses_labels, filename='../logsdir/csv_logs/log_losses.png')\n\n epAndEpoch_reward = df[['epoch', 'episode', 'episode_reward']].dropna(subset=['episode'])\n epAndEpoch_distance = df[['epoch', 'episode', 'distance_to_goal']].dropna(subset=['episode'])\n\n y = epAndEpoch_distance[['distance_to_goal']].values[:, 0]\n x = np.arange(0, len(y))\n plot_curves([(x, y)], 'episode', 'distance to goal (euclidean distance)', title='distance after episode (mixed)',\n window=20, filename='../logsdir/csv_logs/distance.png')\n\ndef plot_distances(df, columns_names, labels, name):\n x = np.arange(0, len(df))\n xs_ys = [(x, df[[k]].values[:, 0]) for k in columns_names]\n plot_curves(xs_ys, 'step', 'distance ', title='distance '+name,\n labels=labels, filename='../logsdir/csv_logs/distance_evaluation_'+name+'.png')\n\n\n\ndef plot_against(path_to_folder,csv_filename_prefix, route1_name, route2_name, epoch):\n df1 = pd.read_csv(path_to_folder + csv_filename_prefix+route1_name + '.csv')\n df2 = pd.read_csv(path_to_folder +csv_filename_prefix+ route2_name + '.csv')\n def plot_ag(columns_names, labels):\n x = np.arange(0, len(df1))\n xs_ys = [(x, df1[[k]].values[:, 0]) for k in columns_names]\n xs_ys2 = [(x, df2[[k]].values[:, 0]) for k in columns_names]\n l1 = [l + '_'+route1_name for l in labels]\n l2 = [l + '_'+route2_name for l in labels]\n plot_curves(xs_ys + xs_ys2, 'step', 'distance ', title='distance ' +route1_name+'_against_'+route2_name,\n labels=l1 + l2,\n filename=path_to_folder + route1_name+'_against_'+\n route2_name+'_'+'_'.join(labels) +'_epoch{}'.format(epoch)+'.png')\n columns_names_goal = ['from_achieved_goal_to_desired_goal_l2_dist']\n labels_goal = ['l2_distance']\n plot_ag(columns_names_goal, labels_goal)\n\n columns_names_goal = ['from_state_latent_to_goal_latent_estimator1']\n labels_goal = ['estimator1']\n plot_ag(columns_names_goal, labels_goal)\n\n columns_names_goal = ['from_state_latent_to_goal_latent_estimator2']\n labels_goal = ['estimator2']\n plot_ag(columns_names_goal, labels_goal)\n\n\ndef plot_distance_estimators(df, name_prefix):\n #to goal\n plot_distances(df, ['from_achieved_goal_to_desired_goal_l2_dist', 'from_state_latent_to_goal_latent_estimator1',\n 'from_state_latent_to_goal_latent_estimator2'],\n ['l2_distance', 'estimator1', 'estimator2'],\n name_prefix + '_distance_to_goal')\n plot_distances(df, ['from_achieved_goal_to_desired_goal_l2_dist', 'from_state_latent_to_goal_latent_estimator1'],\n ['l2_distance', 'estimator1'],\n name_prefix + '_distance_to_goal_estimator_1')\n plot_distances(df, ['from_achieved_goal_to_desired_goal_l2_dist', 'from_state_latent_to_goal_latent_estimator2'],\n ['l2_distance', 'estimator2'],\n name_prefix + '_distance_to_goal_estimator_2')\n # to last state\n plot_distances(df, ['from_achieved_goal_to_achieved_goal_l2_dist', 'from_state_latent_to_state_latent_estimator1',\n 'from_state_latent_to_state_latent_estimator2', 'to_last_steps'],\n ['l2_distance', 'estimator1', 'estimator2', 'steps_distance'],\n name_prefix + '_distance_to_last_state')\n plot_distances(df, ['from_achieved_goal_to_achieved_goal_l2_dist', 'from_state_latent_to_state_latent_estimator1',\n 'to_last_steps'],\n ['l2_distance', 'estimator1', 'steps_distance'],\n name_prefix + '_distance_to_last_state_estimator_1')\n plot_distances(df, ['from_achieved_goal_to_achieved_goal_l2_dist', 'from_state_latent_to_state_latent_estimator2',\n 'to_last_steps'],\n ['l2_distance', 'estimator2', 'steps_distance'],\n name_prefix + '_distance_to_last_state_estimator_2')\n #to last trajectory\n plot_distances(df, ['achieved_goal_l2_dist_traj', 'state_latent_estimator1_traj',\n 'state_latent_estimator2_traj', 'to_last_steps'],\n ['l2_distance', 'estimator1', 'estimator2', 'steps_distance'],\n name_prefix + '_along_trajectory_cumulated')\n plot_distances(df, ['achieved_goal_l2_dist_traj', 'state_latent_estimator1_traj',\n 'to_last_steps'],\n ['l2_distance', 'estimator1', 'steps_distance'],\n name_prefix + '_along_trajectory_cumulated_estimator_1')\n plot_distances(df, ['achieved_goal_l2_dist_traj', 'state_latent_estimator2_traj',\n 'to_last_steps'],\n ['l2_distance', 'estimator2', 'steps_distance'],\n name_prefix + '_along_trajectory_cumulated_estimator_2')\n # to next\n plot_distances(df, ['achieved_goal_to_next_l2_dist', 'state_latent_to_next_estimator1',\n 'state_latent_to_next_estimator2'],\n ['l2_distance', 'estimator1', 'estimator2'],\n name_prefix + '_to_next')\n plot_distances(df, ['achieved_goal_to_next_l2_dist', 'state_latent_to_next_estimator2'],\n ['l2_distance', 'estimator1'],\n name_prefix + '_to_next_estimator_1')\n plot_distances(df, ['achieved_goal_to_next_l2_dist', 'state_latent_to_next_estimator1'],\n ['l2_distance', 'estimator2'],\n name_prefix + '_to_next_estimator_2')\n\ndef plot_distance_estimators_from_training(df, name_prefix):\n #to goal\n plot_distances(df, ['to_goal_l2', 'to_goal_est','to_goal_2est'],\n ['l2_distance', 'estimator1', 'estimator2'],\n name_prefix + '_distance_to_goal')\n plot_distances(df, ['to_goal_l2', 'to_goal_est'],\n ['l2_distance', 'estimator1'],\n name_prefix + '_distance_to_goal_estimator_1')\n plot_distances(df, ['to_goal_l2','to_goal_2est'],\n ['l2_distance', 'estimator2'],\n name_prefix + '_distance_to_goal_estimator_2')\n # to last state\n\n plot_distances(df, ['to_last_l2', 'to_last_est','to_last_2est', 'to_last_steps'],\n ['l2_distance', 'estimator1', 'estimator2', 'steps_distance'],\n name_prefix + '_distance_to_last_state')\n plot_distances(df, ['to_last_l2', 'to_last_est', 'to_last_steps'],\n ['l2_distance', 'estimator1', 'steps_distance'],\n name_prefix + '_distance_to_last_state_estimator_1')\n plot_distances(df, ['to_last_l2','to_last_2est', 'to_last_steps'],\n ['l2_distance', 'estimator2', 'steps_distance'],\n name_prefix + '_distance_to_last_state_estimator_2')\n #to last trajectory\n plot_distances(df, ['to_last_l2_traj', 'to_last_est_traj','to_last_2est_traj', 'to_last_steps'],\n ['l2_distance', 'estimator1', 'estimator2', 'steps_distance'],\n name_prefix + '_along_trajectory_cumulated')\n plot_distances(df, ['to_last_l2_traj', 'to_last_est_traj', 'to_last_steps'],\n ['l2_distance', 'estimator1', 'steps_distance'],\n name_prefix + '_along_trajectory_cumulated_estimator_1')\n plot_distances(df, ['to_last_l2_traj','to_last_2est_traj', 'to_last_steps'],\n ['l2_distance', 'estimator2', 'steps_distance'],\n name_prefix + '_along_trajectory_cumulated_estimator_2')\n\n # to next\n plot_distances(df, ['to_next_l2','to_next_est','to_next_2est'],\n ['l2_distance', 'estimator1', 'estimator2'],\n name_prefix + '_to_next')\n plot_distances(df, ['to_next_l2','to_next_est'],\n ['l2_distance', 'estimator1'],\n name_prefix + '_to_next_estimator_1')\n plot_distances(df, ['to_next_l2','to_next_2est'],\n ['l2_distance', 'estimator2'],\n name_prefix + '_to_next_estimator_2')\n\ndef plot_distance_group(df, name_prefix):\n def p_points(columns_names, labels, name):\n x = np.arange(0, len(df))\n xs_ys = [(x, df[[k]].values[:, 0]) for k in columns_names]\n plot_curves(xs_ys, 'pair', 'distance', title='distance ' + name,\n labels=labels, filename='../logsdir/csv_logs/distance_evaluation_' + name + '.png')\n p_points(['l2_dist'],['l2_distance'],name_prefix + 'l2_distance')\n p_points(['estimator1'], ['estimator1'],name_prefix + 'estimator1')\n p_points(['estimator2'],['estimator2'],name_prefix + 'estimator2')\n\n\n\nif __name__ == \"__main__\":\n epoch = 390\n '''\n df = pd.read_csv('../logsdir/csv_logs/dist_no_obstacle_epoch_120_it_0.csv')\n plot_distance_estimators_from_training(df,'from_training_epoch_120_it_0')\n '''\n l = ['random','route_1','route_2','route_3_1','route_3_2','route_3_3','route_4_1','route_4_2']\n for r in l:\n df = pd.read_csv('../logsdir/csv_logs/distance_evaluation_'+r+'.csv')\n plot_distance_estimators(df, r+'_epoch_{}_'.format(epoch))\n\n plot_against('../logsdir/csv_logs/','distance_evaluation_','route_3_1','route_3_2', epoch)\n plot_against('../logsdir/csv_logs/', 'distance_evaluation_', 'route_4_1', 'route_4_2', epoch)\n\n for gr in ['a','b','c','d','e','f', 'g', 'h', 'i']:\n df = pd.read_csv('../logsdir/csv_logs/group_'+gr+'.csv')\n plot_distance_group(df, 'group_'+gr+'_epoch_{}_'.format(epoch))\n\n\n\n" ]

[ [ "matplotlib.pyplot.legend", "matplotlib.pyplot.tight_layout", "pandas.read_csv", "matplotlib.pyplot.title", "matplotlib.pyplot.savefig", "numpy.lib.stride_tricks.as_strided", "matplotlib.pyplot.plot", "matplotlib.pyplot.xlim", "matplotlib.pyplot.ylabel", "matplotlib.pyplot.xlabel", "matplotlib.pyplot.figure" ] ]

Preston5789/Stock_Regression_Algorithm

[ "f65dd0c710be777628a0c03ce0fa851880cf0d81" ]

[ "stock_plots.py" ]

[ "\r\nimport matplotlib.pyplot as plt\r\nimport numpy\r\nimport time\r\nfrom matplotlib.widgets import Button\r\n\r\nfrom stock_trade import Jesus\r\nfrom stock_connect import Connection\r\nfrom stock_reg import Errors\r\n\r\nerr = Errors()\r\n\r\ngraphswitcheroo = 0\r\n\r\n\r\ncon = Connection()\r\njes = Jesus()\r\ncon.socket()\r\n\r\nplt.ion()\r\nfig, axs = plt.subplots(4, 1,figsize=(8,10), constrained_layout=True)\r\nx1, y1 = [],[]\r\nx2, y2 = [], []\r\nx3, y3 = [], []\r\nx4, y4 = [], []\r\nbuyx, buyy = [], []\r\nsellx, selly = [], []\r\n\r\ns=2\r\n\r\nlivedata = axs[0].scatter(x1,y1,s=s, c = 'blue')\r\nselldata = axs[0].scatter(sellx, selly, s = 15, c = 'r')\r\nbuydata = axs[0].scatter(buyx, buyy, s = 15, c = 'g')\r\nlnn, = axs[0].plot([],[], 'green', linewidth = 1.0)\r\nln, = axs[0].plot([],[],'red', linewidth = 1.0)\r\n\r\naxs[0].set_title('Live Data')\r\naxs[1].set_title('Linear Regression Analysis')\r\naxs[1].set_ylabel('Slope Value')\r\naxs[0].set_ylabel('Price Over Time')\r\naxs[0].set_xlabel('time (s)')\r\naxs[1].set_xlabel('time (s)')\r\n\r\n\r\nln1, = axs[1].plot([],[], 'r', linewidth = 0.2,)\r\nln2, = axs[1].plot([],[], 'r', linewidth=0.2)\r\nln11, = axs[1].plot([],[], 'g', linewidth=0.4)\r\nln22, = axs[1].plot([],[], 'g', linewidth=0.4)\r\nslopedata = axs[1].scatter(x3,y3, s=s, c = 'black')\r\nslopedata2 = axs[1].scatter(x4,y4, s=s, c = 'blue')\r\nmaxtime = time.time()*1000.0 + 20000\r\nbegintime = time.time()*1000.0\r\naxs[0].set_xlim(begintime,maxtime)\r\naxs[1].set_xlim(begintime,maxtime)\r\naxs[0].grid()\r\naxs[1].grid()\r\nplt.draw()\r\n\r\n\r\naxs[2].set_title('Regression Trader: Control Panel')\r\naxs[3].set_title('Historical Data')\r\naxs[2].set_ylabel('Price')\r\naxs[2].set_xlabel('Server Time')\r\nticker_text = fig.text(0.5, 0.43, '' , multialignment=\"left\")\r\ntime_text = fig.text(0.5, 0.40, '' , multialignment=\"left\")\r\nyield_text = fig.text(0.5, 0.37, '', multialignment=\"left\")\r\nlossyield_text = fig.text(0.5, 0.34, '', multialignment=\"left\")\r\ntotalsell_text = fig.text(0.5, 0.31, '', multialignment=\"left\")\r\n\r\n\r\ndef _closeshop(event,tickerlist):\r\n jes.closeshop(tickerlist)\r\n\r\ndef on_click(event):\r\n print('doubleclick')\r\n\r\n#definition to cycle through graphs\r\ndef _yes(event):\r\n global graphswitcheroo\r\n graphswitcheroo += 1\r\n if(graphswitcheroo>=14):\r\n graphswitcheroo = 0\r\n\r\n\r\n\r\n#Renders the graph for all of the trading data\r\ndef _rendergraph(event):\r\n print('Generating Graph')\r\n axs[3].clear()\r\n axs[2].set_title('Regression Trader: Controll Panel')\r\n axs[3].set_title('Historical Data')\r\n axs[3].set_ylabel('Price')\r\n axs[3].set_xlabel('Server Time')\r\n axs[3].grid()\r\n x5 = [float(i) for i in con.trackertime_list[graphswitcheroo]]\r\n y5 = [float(i) for i in con.tracker_list[graphswitcheroo]]\r\n axs[3].plot(x5,y5)\r\n axs[3].scatter(sellx, selly,c='red', linewidths=2.0,edgecolors='black',s=60)\r\n axs[3].scatter(buyx,buyy,c='green',linewidths=2.0,edgecolors='black',s=60)\r\n\r\n#Everything to get the buttons together\r\nplt.connect('button_press_event', on_click)\r\nnexcut = plt.axes([0.15, 0.40, .17, .05], facecolor='k')\r\ngraphcut = plt.axes([0.15, 0.32, .3,.06], facecolor = 'k')\r\nwrapcut = plt.axes([0.78, 0.38, .17,.05], facecolor = 'k')\r\nbnexcut = Button(nexcut, 'Next Stock', color='red', hovercolor='white')\r\nbgraphcut = Button(graphcut, 'Generate Graph', color='blue', hovercolor='white')\r\nbwrapcut = Button(wrapcut, 'Wrap It Up', color='yellow',hovercolor='white')\r\nbgraphcut.on_clicked(_rendergraph)\r\nbnexcut.on_clicked(_yes)\r\nbwrapcut.on_clicked(_closeshop)\r\n\r\n\r\n\r\nwhile(True):\r\n\r\n #print(con.tracker_list)\r\n x1 = [float(i) for i in con.trackertime_list[graphswitcheroo][-1000:]]\r\n y1 = [float(i) for i in con.tracker_list[graphswitcheroo][-1000:]]\r\n x2 =[float(i) for i in con.temptime_list[graphswitcheroo]]\r\n y2 =[float(i) for i in con.temp_list[graphswitcheroo]]\r\n buyx = [float(i) for i in jes.buytime_list[graphswitcheroo]]\r\n buyy = [float(i) for i in jes.buy_list[graphswitcheroo]]\r\n sellx =[float(i) for i in jes.selltime_list[graphswitcheroo]]\r\n selly =[float(i) for i in jes.sell_list[graphswitcheroo]]\r\n\r\n\r\n ##Make sure the graphs are all tidy like\r\n if((len(y1)>0)):\r\n axs[0].set_ylim(0.98*float(min(y1)) ,1.02*float(max(y1)))\r\n time_text.set_text('Current Price: ' + con.temp_list[graphswitcheroo][0].rstrip('0'))\r\n ticker_text.set_text(con.tickerlist[graphswitcheroo])\r\n yield_text.set_text('Permanent Yield: ' + str(jes.tdyyield))\r\n lossyield_text.set_text('Unsold Yield: ' + str(sum(jes.lssyield)))\r\n totalsell_text.set_text('Amount of Trades Holding Assets: ' + str(sum(jes.totalsell)))\r\n axs[0].set_xlim(float(x1[0]), float(x1[-1]))\r\n axs[1].set_xlim(float(x1[0]), float(x1[-1]))\r\n\r\n if(len(buyx) == len(buyy)):\r\n buydata.set_offsets(numpy.c_[buyx, buyy])\r\n if(len(sellx)==len(selly)):\r\n selldata.set_offsets(numpy.c_[sellx, selly])\r\n if(numpy.shape(numpy.array(x1))==numpy.shape(numpy.array(y1))):\r\n livedata.set_offsets(numpy.c_[x1, y1])\r\n\r\n toparray = [float(i) for i in con.toperror_list[graphswitcheroo]]\r\n print(toparray)\r\n bottomarray = [float(i) for i in con.bottomerror_list[graphswitcheroo]]\r\n toparray2 = [float(i) for i in con.toperror2_list[graphswitcheroo]]\r\n bottomarray2 = [float(i) for i in con.bottomerror2_list[graphswitcheroo]]\r\n\r\n\r\n if(len(con.tracker_list[graphswitcheroo])>=35):\r\n\r\n\r\n x3 =[float(i) for i in con.slopetime_list[graphswitcheroo]]\r\n y3 =[float(i) for i in con.slope_list[graphswitcheroo]]\r\n ln1.set_data(x3, toparray)\r\n ln2.set_data(x3, bottomarray)\r\n\r\n print(\"The dimensin of x2 is: {}\".format(len(x2)))\r\n print(\"The dimensin of of line1 is: {}\".format(len(con.line1_list[graphswitcheroo])))\r\n print(con.line1_list[graphswitcheroo])\r\n ln.set_data(x2,con.line1_list[graphswitcheroo])\r\n slopedata.set_offsets(numpy.c_[x3,y3])\r\n\r\n axs[1].set_xlim(x3[0], x3[-1])\r\n axs[1].set_ylim(min(bottomarray),max(toparray))\r\n\r\n if(len(con.tracker_list[graphswitcheroo])>=95):\r\n x4 =[float(i) for i in con.slopetime2_list[graphswitcheroo]]\r\n y4 =[float(i) for i in con.slope2_list[graphswitcheroo]]\r\n y60 = [float(i) for i in con.line2_list[graphswitcheroo]]\r\n x60 = [float(i) for i in con.temptime2_list[graphswitcheroo][0:64]]\r\n ln11.set_data(x4, toparray2)\r\n ln22.set_data(x4, bottomarray2)\r\n lnn.set_data(x60 ,y60)\r\n slopedata2.set_offsets(numpy.c_[x4,y4])\r\n\r\n for i in range(len(con.tickerlist)):\r\n if len(con.tracker_list[i])>100:\r\n jes.defender[i] = True;\r\n\r\n Jesus().decide(con.startbalnace, con.toperror_list, con.bottomerror_list, con.toperror2_list, con.bottomerror2_list, con.temp_list, con.temptime_list, con.tickerlist, con.tracker_list)\r\n\r\n plt.pause(0.01)\r\n\r\n\r\n" ]

[ [ "matplotlib.pyplot.connect", "matplotlib.widgets.Button", "matplotlib.pyplot.subplots", "matplotlib.pyplot.draw", "matplotlib.pyplot.axes", "numpy.array", "matplotlib.pyplot.ion", "matplotlib.pyplot.pause" ] ]

rayjyh/PyTorch_CIFAR10_rram_compenstion

[ "61a53c85a74abc965a5bea3e4b102e9a7ad8f03a" ]

[ "modify_weights.py" ]

[ "import numpy as np\nimport matplotlib.pyplot as plt\nimport torch\n\n'''\ncompensation = {\n \"no_comp\":\n \"simple\":\n \"dynamic\":\n \"bias\":\n \"double_sim\":\n}\n'''\n\nquantized = True\nvisualize = False\nsymmetric = True\n\n\ndef asym_quant_param(w, k):\n num_intervals = 2 ** k - 1\n scale = (torch.max(w) - torch.min(w)) / num_intervals\n zero = int(-torch.min(w) / scale)\n return num_intervals, scale, zero\n\n\ndef sym_quant_param(w, k):\n num_intervals = 2 ** k - 1\n scale = max(torch.max(w), -torch.min(w)) / num_intervals\n return num_intervals, scale\n\n\ndef asym_quant(w, num_intervals, scale, zero):\n w_q = torch.round(w / scale) + zero\n w_q = torch.clamp(w_q, 0, num_intervals)\n return w_q\n\n\ndef sym_quant(w, num_intervals, scale):\n w_q = torch.round(w / scale)\n w_q = torch.clamp(w_q, -num_intervals, num_intervals - 1)\n return w_q\n\n\ndef asym_de_quant(w_q, scale, zero):\n w_dq = (w_q - zero) * scale\n return w_dq\n\n\ndef sym_de_quant(w_q, scale):\n w_dq = w_q * scale\n return w_dq\n\n\nclass Compensation:\n def __init__(self,\n absolute_variation=0,\n normal_dist=0,\n var=5,\n var_percentage=7.2,\n scale=10,\n sd=5,\n sd_percentage=0,\n bias=5,\n k_bits=4):\n self.absolute_variation = absolute_variation\n self.normal_dist = normal_dist\n # self.var = var\n self.var_percentage = var_percentage\n self.scale = scale\n self.sd = sd\n self.sd_percentage = sd_percentage\n self.k_bits = k_bits\n self.max = 2 ** self.k_bits - 1\n self.sd = self.sd_percentage * self.max\n self.var = var # * self.max\n self.bias = bias * self.max\n\n def no_comp(self, w):\n if self.absolute_variation:\n pos = torch.abs(w)\n maximum = torch.mean(pos)\n std = self.var * maximum.item()\n real = torch.normal(w, std)\n else:\n if self.normal_dist:\n real = torch.normal(w, self.var_percentage * abs(w))\n else:\n real = w * torch.exp(torch.normal(0, self.var_percentage, size=w.shape, device=w.device))\n # real = torch.clamp(real, 0, self.max)\n return real\n\n def simple(self, w):\n if self.absolute_variation:\n real = torch.normal(w, self.var)\n else:\n real = torch.normal(w, self.var_percentage * abs(w))\n # real = torch.clamp(real, 0, self.max)\n gtz = w > torch.zeros_like(w)\n # stz = w < torch.zeros_like(w)\n gtw = real > w\n # stw = real < w\n # condition = (gtz * gtw) + (stz * stw)\n condition = gtz * gtw\n pre_diff = w - real\n if absolute_variation:\n comp = torch.normal(pre_diff * self.scale, self.var)\n else:\n comp = torch.normal(pre_diff * self.scale, self.var_percentage * abs(pre_diff * self.scale))\n # comp = torch.clamp(comp, 0, self.max)\n new = real + comp / self.scale\n new = torch.where(condition, real, new)\n post_diff = w - new\n return new\n\n def dynamic(self, w):\n # self.sd = self.sd_percentage * self.var_percentage * w\n # pos_shift_target = w - self.sd\n # neg_shift_target = w + self.sd\n if self.absolute_variation:\n pos_real = torch.normal(w - self.sd, self.var)\n neg_real = torch.normal(w + self.sd, self.var)\n real = torch.where(w > 0, pos_real, neg_real)\n else:\n pos_real = torch.normal(w - self.sd, self.var_percentage * abs(w - self.sd))\n neg_real = torch.normal(w + self.sd, self.var_percentage * abs(w + self.sd))\n real = torch.where(w > 0, pos_real, neg_real)\n # real = torch.clamp(real, 0, self.max)\n gtz = w > torch.zeros_like(w)\n # stz = w < torch.zeros_like(w)\n gtw = real > w\n # stw = real < w\n # condition = (gtz * gtw) + (stz * stw)\n condition = gtz * gtw\n pre_diff = w - real\n if self.absolute_variation:\n comp = torch.normal(pre_diff * self.scale, self.var)\n else:\n comp = torch.normal(pre_diff * self.scale, self.var_percentage * abs(pre_diff * self.scale))\n # comp = torch.clamp(comp, 0, self.max)\n new = real + comp / self.scale\n new = torch.where(condition, real, new)\n post_diff = w - new\n return new # , real, pre_diff, post_diff\n\n def bias_comp(self, w):\n if self.absolute_variation:\n real = torch.normal(w, self.var)\n else:\n real = torch.normal(w, self.var_percentage * abs(w))\n # real = torch.clamp(real, 0, self.max)\n pre_diff = w - real\n pre_diff = torch.clamp(pre_diff, min=-self.bias)\n if self.absolute_variation:\n comp = torch.normal((pre_diff + self.bias) * self.scale, self.var)\n else:\n comp = torch.normal((pre_diff + self.bias) * self.scale,\n self.var_percentage * abs((pre_diff + self.bias) * self.scale))\n # comp = torch.where(comp > x, comp, gmin * torch.ones_like(comp))\n # comp = torch.clamp(comp, min=0)\n new = real + comp / self.scale - self.bias\n post_diff = w - new\n # return real, new, pre_diff, post_diff\n return new\n\n def double_sim(self, w):\n if self.absolute_variation:\n real = torch.normal(w, self.var)\n else:\n real = torch.normal(w, self.var_percentage * abs(w))\n # real = torch.clamp(real, 0, self.max)\n diff = w - real\n if self.absolute_variation:\n comp = torch.normal(diff * self.scale, self.var)\n else:\n comp = torch.normal(diff * self.scale, self.var_percentage * abs(diff * self.scale))\n comp = torch.clamp(comp, -self.max, self.max)\n return real + comp / self.scale\n\n\ndef multi_cell(w, k_bits, n_cells, compensation, modification=None, method=\"normal\"):\n assert k_bits % n_cells == 0, \"k_bits must be divisible by n_cells!\"\n # quantization\n if symmetric:\n num_intervals, scale = sym_quant_param(w, k_bits)\n w_q = sym_quant(w, num_intervals, scale).to(torch.int64)\n neg_mask = torch.where(w_q < 0, -1, 1)\n w_q = w_q * neg_mask\n else:\n num_intervals, scale, zero = asym_quant_param(w, k_bits)\n w_q = asym_quant(w, num_intervals, scale, zero).to(torch.int64)\n\n if n_cells > 1:\n # convert to binary digits\n mask = 2 ** torch.arange(k_bits - 1, -1, -1, device=w.device)\n w_binary = w_q.unsqueeze(-1).bitwise_and(mask).ne(0).int()\n\n # split into multi cells\n bits_per_cell = int(k_bits / n_cells)\n w_binary_mc = torch.chunk(w_binary, n_cells, -1)\n # get the decimal of each cell\n mask_mc = 2 ** torch.arange(bits_per_cell - 1, -1, -1, device=w.device)\n mask_mc = [chunk * torch.ones(w.shape, device=w.device) for chunk in mask_mc]\n mask_mc = torch.stack(mask_mc, -1)\n w_mc = [chunk.mul(mask_mc).sum(-1) for chunk in w_binary_mc]\n\n # apply variation and compensation if any\n if modification is not None:\n compensation.var = compensation.var / (2 ** (k_bits - bits_per_cell))\n compensation.var_percentage = compensation.var_percentage / (2 ** (k_bits - bits_per_cell))\n compensation.sd = compensation.sd / (2 ** (k_bits - bits_per_cell))\n compensation.bias = compensation.bias / (2 ** (k_bits - bits_per_cell))\n # variation-aware programming\n if method == \"variation_aware_programming\":\n w_mc_m = []\n vap_flag = torch.zeros_like(w_mc[0]).type(torch.bool)\n for i, chunk in enumerate(w_mc):\n cell_max = modification((2 ** bits_per_cell - 1) * torch.ones_like(chunk))\n w_mc_m.append(torch.where(vap_flag, cell_max, modification(chunk)))\n msb_diff = abs(w_mc[i] - w_mc_m[i])\n vap_flag = torch.logical_or(vap_flag, torch.where(msb_diff > 0.5, True, False))\n elif method == \"msb_only\":\n msb = [modification(w_mc[0])]\n lsb = [compensation.no_comp(chunk) for chunk in w_mc[1:]]\n w_mc_m = msb + lsb\n else:\n w_mc_m = [modification(chunk) for chunk in w_mc]\n w_mc = w_mc_m\n\n # merge multi cells into one weight\n magnitude = (2 ** bits_per_cell) ** torch.arange(n_cells - 1, -1, -1, device=w.device)\n mag_w = list(zip(w_mc, magnitude))\n w_mc_mag = [chunk[0] * chunk[1] for chunk in mag_w]\n w_q_m = torch.stack(w_mc_mag, -1).sum(-1)\n else:\n if modification is None:\n w_q_m = w_q\n else:\n w_q_m = modification(w_q.to(torch.float32))\n\n # dequantize\n if symmetric:\n w_q_m = w_q_m * neg_mask\n w_q_m_dq = sym_de_quant(w_q_m, scale)\n else:\n w_q_m_dq = asym_de_quant(w_q_m, scale, zero)\n return w_q_m_dq\n\n\ndef modify_weight(weight_dict, layer_list, k_bits, n_cells, compensation, modification=None):\n for layer in weight_dict.keys():\n # if len(re.findall(r\"(fc|conv)\", layer)) != 0:\n if layer in layer_list:\n # visualize weight distribution\n og_weight = weight_dict[layer].detach().clone()\n if quantized:\n weight_dict[layer] = multi_cell(weight_dict[layer], k_bits, n_cells, compensation, modification)\n else:\n if modification is None:\n return\n else:\n # weight_dict[layer], ns_weight, pre_diff, post_diff = modification(weight_dict[layer])\n weight_dict[layer] = modification(weight_dict[layer])\n dq_weight = weight_dict[layer].detach().clone()\n if visualize:\n # weight_np = weight_dict[conv + '.weight'].numpy()\n # weight_np = weight_dict[layer].numpy()\n # plt.figure()\n plt.hist(og_weight.cpu().numpy().flatten(), 200, alpha=0.4, color='red', label='weight')\n # plt.hist(w_q.cpu().numpy().flatten(), 200, alpha=0.6, color='yellow', label='quantized_weight')\n plt.hist(dq_weight.cpu().numpy().flatten(), 200, alpha=0.4, color='blue', label='de_quant_weight')\n plt.legend()\n # plt.show()\n plt.savefig(\"/home/huangyc/jingyuhe/Pytorch_CIFAR10/dy_comp_weight/\" + layer + \"_weight.png\")\n plt.close()\n\n # plt.figure()\n plt.hist(pre_diff.cpu().numpy().flatten(), 200, alpha=0.4, color='purple', label='pre_comp errors')\n plt.hist(post_diff.cpu().numpy().flatten(), 200, alpha=0.4, color='yellow', label='post_comp errors')\n plt.legend()\n # plt.show()\n plt.savefig(\"/home/huangyc/jingyuhe/Pytorch_CIFAR10/dy_comp_weight/\" + layer + \"_diff.png\")\n plt.close()\n\n'''\ntmp = torch.normal(0, 0.2, size=(3, 3), device=\"cuda:0\")\ncompensation = Compensation()\nmulti_cell(tmp, 6, 3, compensation, compensation.dynamic, method=\"variation_aware_programming\")\n'''" ]

[ [ "torch.normal", "torch.abs", "torch.mean", "matplotlib.pyplot.legend", "torch.ones", "torch.max", "torch.round", "torch.min", "torch.zeros_like", "matplotlib.pyplot.savefig", "torch.where", "torch.arange", "torch.chunk", "matplotlib.pyplot.close", "torch.clamp", "torch.ones_like", "torch.stack" ] ]

Dzhange/rex-gym

[ "3ffb674ade13ceac3352c3329f1804eb21a08403" ]

[ "rex_gym/envs/gym/walk_env.py" ]

[ "\"\"\"This file implements the gym environment of rex alternating legs.\n\n\"\"\"\nimport math\nimport random\n\nfrom gym import spaces\nimport numpy as np\nfrom .. import rex_gym_env\nfrom ...model import rex_constants\nfrom ...model.gait_planner import GaitPlanner\nfrom ...model.kinematics import Kinematics\n\nNUM_LEGS = 4\n\n\nclass RexWalkEnv(rex_gym_env.RexGymEnv):\n \"\"\"The gym environment for the rex.\n\n It simulates the locomotion of a rex, a quadruped robot. The state space\n include the angles, velocities and torques for all the motors and the action\n space is the desired motor angle for each motor. The reward function is based\n on how far the rex walks in 2000 steps and penalizes the energy\n expenditure or how near rex is to the target position.\n\n \"\"\"\n metadata = {\"render.modes\": [\"human\", \"rgb_array\"], \"video.frames_per_second\": 66}\n load_ui = True\n is_terminating = False\n\n def __init__(self,\n debug=False,\n urdf_version=None,\n control_time_step=0.005,\n action_repeat=5,\n control_latency=0,\n pd_latency=0,\n on_rack=False,\n motor_kp=1.0,\n motor_kd=0.02,\n render=False,\n num_steps_to_log=2000,\n env_randomizer=None,\n log_path=None,\n target_position=None,\n backwards=None,\n signal_type=\"ik\",\n terrain_type=\"plane\",\n terrain_id=None,\n mark='base'):\n \"\"\"Initialize the rex alternating legs gym environment.\n\n Args:\n urdf_version: [DEFAULT_URDF_VERSION, DERPY_V0_URDF_VERSION] are allowable\n versions. If None, DEFAULT_URDF_VERSION is used. Refer to\n rex_gym_env for more details.\n control_time_step: The time step between two successive control signals.\n action_repeat: The number of simulation steps that an action is repeated.\n control_latency: The latency between get_observation() and the actual\n observation. See minituar.py for more details.\n pd_latency: The latency used to get motor angles/velocities used to\n compute PD controllers. See rex.py for more details.\n on_rack: Whether to place the rex on rack. This is only used to debug\n the walk gait. In this mode, the rex's base is hung midair so\n that its walk gait is clearer to visualize.\n motor_kp: The P gain of the motor.\n motor_kd: The D gain of the motor.\n remove_default_joint_damping: Whether to remove the default joint damping.\n render: Whether to render the simulation.\n num_steps_to_log: The max number of control steps in one episode. If the\n number of steps is over num_steps_to_log, the environment will still\n be running, but only first num_steps_to_log will be recorded in logging.\n env_randomizer: An instance (or a list) of EnvRanzomier(s) that can\n randomize the environment during when env.reset() is called and add\n perturbations when env.step() is called.\n log_path: The path to write out logs. For the details of logging, refer to\n rex_logging.proto.\n \"\"\"\n super(RexWalkEnv,\n self).__init__(urdf_version=urdf_version,\n accurate_motor_model_enabled=True,\n motor_overheat_protection=True,\n hard_reset=False,\n motor_kp=motor_kp,\n motor_kd=motor_kd,\n remove_default_joint_damping=False,\n control_latency=control_latency,\n pd_latency=pd_latency,\n on_rack=on_rack,\n render=render,\n num_steps_to_log=num_steps_to_log,\n env_randomizer=env_randomizer,\n log_path=log_path,\n control_time_step=control_time_step,\n action_repeat=action_repeat,\n target_position=target_position,\n signal_type=signal_type,\n backwards=backwards,\n debug=debug,\n terrain_id=terrain_id,\n terrain_type=terrain_type,\n mark=mark)\n # (eventually) allow different feedback ranges/action spaces for different signals\n action_max = {\n 'ik': 0.4,\n 'ol': 0.01\n }\n action_dim_map = {\n 'ik': 2,\n 'ol': 8\n }\n action_dim = action_dim_map[self._signal_type]\n action_high = np.array([action_max[self._signal_type]] * action_dim)\n self.action_space = spaces.Box(-action_high, action_high)\n self._cam_dist = 1.0\n self._cam_yaw = 0.0\n self._cam_pitch = -20\n self._signal_type = signal_type\n self._gait_planner = GaitPlanner(\"walk\")\n self._kinematics = Kinematics()\n self.goal_reached = False\n self._stay_still = False\n self.is_terminating = False\n\n def reset(self):\n self.init_pose = rex_constants.INIT_POSES[\"stand\"]\n if self._signal_type == 'ol':\n self.init_pose = rex_constants.INIT_POSES[\"stand_ol\"]\n super(RexWalkEnv, self).reset(initial_motor_angles=self.init_pose, reset_duration=0.5)\n self.goal_reached = False\n self.is_terminating = False\n self._stay_still = False\n if self._backwards is None:\n self.backwards = random.choice([True, False])\n else:\n self.backwards = self._backwards\n step = 0.6\n period = 0.65\n base_x = self._base_x\n if self.backwards:\n step = -.3\n period = .5\n base_x = .0\n if not self._target_position or self._random_pos_target:\n bound = -3 if self.backwards else 3\n self._target_position = random.uniform(bound//2, bound)\n self._random_pos_target = True\n if 1 or (self._is_render and self._signal_type == 'ik'):\n if self.load_ui:\n self.setup_ui(base_x, step, period)\n self.load_ui = False\n if self._is_debug:\n print(f\"Target Position x={self._target_position}, Random assignment: {self._random_pos_target}, Backwards: {self.backwards}\")\n return self._get_observation()\n\n def setup_ui(self, base_x, step, period):\n self.base_x_ui = self._pybullet_client.addUserDebugParameter(\"base_x\",\n self._ranges[\"base_x\"][0],\n self._ranges[\"base_x\"][1],\n base_x)\n self.base_y_ui = self._pybullet_client.addUserDebugParameter(\"base_y\",\n self._ranges[\"base_y\"][0],\n self._ranges[\"base_y\"][1],\n self._ranges[\"base_y\"][2])\n self.base_z_ui = self._pybullet_client.addUserDebugParameter(\"base_z\",\n self._ranges[\"base_z\"][0],\n self._ranges[\"base_z\"][1],\n self._ranges[\"base_z\"][2])\n self.roll_ui = self._pybullet_client.addUserDebugParameter(\"roll\",\n self._ranges[\"roll\"][0],\n self._ranges[\"roll\"][1],\n self._ranges[\"roll\"][2])\n self.pitch_ui = self._pybullet_client.addUserDebugParameter(\"pitch\",\n self._ranges[\"pitch\"][0],\n self._ranges[\"pitch\"][1],\n self._ranges[\"pitch\"][2])\n self.yaw_ui = self._pybullet_client.addUserDebugParameter(\"yaw\",\n self._ranges[\"yaw\"][0],\n self._ranges[\"yaw\"][1],\n self._ranges[\"yaw\"][2])\n self.step_length_ui = self._pybullet_client.addUserDebugParameter(\"step_length\", -0.7, 0.7, step)\n self.step_rotation_ui = self._pybullet_client.addUserDebugParameter(\"step_rotation\", -1.5, 1.5, 0.)\n self.step_angle_ui = self._pybullet_client.addUserDebugParameter(\"step_angle\", -180., 180., 0.)\n self.step_period_ui = self._pybullet_client.addUserDebugParameter(\"step_period\", 0.2, 0.9, period)\n\n def _read_inputs(self, base_pos_coeff, gait_stage_coeff):\n position = np.array(\n [\n self._pybullet_client.readUserDebugParameter(self.base_x_ui),\n self._pybullet_client.readUserDebugParameter(self.base_y_ui) * base_pos_coeff,\n self._pybullet_client.readUserDebugParameter(self.base_z_ui) * base_pos_coeff\n ]\n )\n orientation = np.array(\n [\n self._pybullet_client.readUserDebugParameter(self.roll_ui) * base_pos_coeff,\n self._pybullet_client.readUserDebugParameter(self.pitch_ui) * base_pos_coeff,\n self._pybullet_client.readUserDebugParameter(self.yaw_ui) * base_pos_coeff\n ]\n )\n step_length = self._pybullet_client.readUserDebugParameter(self.step_length_ui) * gait_stage_coeff\n step_rotation = self._pybullet_client.readUserDebugParameter(self.step_rotation_ui)\n step_angle = self._pybullet_client.readUserDebugParameter(self.step_angle_ui)\n step_period = self._pybullet_client.readUserDebugParameter(self.step_period_ui)\n return position, orientation, step_length, step_rotation, step_angle, step_period\n\n def _check_target_position(self, t):\n if self._target_position:\n current_x = abs(self.rex.GetBasePosition()[0])\n # give 0.15 stop space\n if current_x >= abs(self._target_position) - 0.15:\n self.goal_reached = True\n if not self.is_terminating:\n self.end_time = t\n self.is_terminating = True\n\n @staticmethod\n def _evaluate_base_stage_coeff(current_t, end_t=0.0, width=0.001):\n # sigmoid function\n beta = p = width\n if p - beta + end_t <= current_t <= p - (beta / 2) + end_t:\n return (2 / beta ** 2) * (current_t - p + beta) ** 2\n elif p - (beta/2) + end_t <= current_t <= p + end_t:\n return 1 - (2 / beta ** 2) * (current_t - p) ** 2\n else:\n return 1\n\n @staticmethod\n def _evaluate_gait_stage_coeff(current_t, action, end_t=0.0):\n # ramp function\n p = 0.8 + action[0]\n if end_t <= current_t <= p + end_t:\n return current_t\n else:\n return 1.0\n\n @staticmethod\n def _evaluate_brakes_stage_coeff(current_t, action, end_t=0.0, end_value=0.0):\n # ramp function\n p = 0.8 + action[1]\n if end_t <= current_t <= p + end_t:\n return 1 - (current_t - end_t)\n else:\n return end_value\n\n def _signal(self, t, action):\n if self._signal_type == 'ik':\n return self._IK_signal(t, action)\n if self._signal_type == 'ol':\n return self._open_loop_signal(t, action)\n\n def _IK_signal(self, t, action):\n base_pos_coeff = self._evaluate_base_stage_coeff(t, width=1.5)\n gait_stage_coeff = self._evaluate_gait_stage_coeff(t, action)\n step = 0.6\n period = 0.65\n base_x = self._base_x\n if self.backwards:\n step = -.3\n period = .5\n base_x = .0\n if (self._is_render and self._is_debug):\n position, orientation, step_length, step_rotation, step_angle, step_period = \\\n self._read_inputs(base_pos_coeff, gait_stage_coeff)\n # elif 0 and self._is_debug:\n # # print(\"here\")\n # position = np.array([base_x,\n # self._base_y * base_pos_coeff,\n # self._base_z * base_pos_coeff])\n # orientation = np.array([self._base_roll * base_pos_coeff,\n # self._base_pitch * base_pos_coeff,\n # self._base_yaw * base_pos_coeff])\n # step_length = -0.3\n # step_rotation = 0\n # step_angle = 0\n # step_period = 0.5 \n else:\n position = np.array([base_x,\n self._base_y * base_pos_coeff,\n self._base_z * base_pos_coeff])\n orientation = np.array([self._base_roll * base_pos_coeff,\n self._base_pitch * base_pos_coeff,\n self._base_yaw * base_pos_coeff])\n step_length = (self.step_length if self.step_length is not None else step) * gait_stage_coeff\n step_rotation = (self.step_rotation if self.step_rotation is not None else 0.0)\n step_angle = self.step_angle if self.step_angle is not None else 0.0\n step_period = (self.step_period if self.step_period is not None else period)\n # print(position, orientation, step_length, step_rotation, step_angle, step_period)\n if self.goal_reached:\n brakes_coeff = self._evaluate_brakes_stage_coeff(t, action, self.end_time)\n step_length *= brakes_coeff\n if brakes_coeff == 0.0:\n self._stay_still = True\n direction = -1.0 if step_length < 0 else 1.0\n frames = self._gait_planner.loop(step_length, step_angle, step_rotation, step_period, direction)\n fr_angles, fl_angles, rr_angles, rl_angles, _ = self._kinematics.solve(orientation, position, frames)\n signal = [\n fl_angles[0], fl_angles[1], fl_angles[2],\n fr_angles[0], fr_angles[1], fr_angles[2],\n rl_angles[0], rl_angles[1], rl_angles[2],\n rr_angles[0], rr_angles[1], rr_angles[2]\n ]\n return signal\n\n def _open_loop_signal(self, t, action):\n period = 1.0 / 8\n l_a = 0.1\n f_a = l_a * 2\n if self.goal_reached:\n coeff = self._evaluate_brakes_stage_coeff(t, [0., 0.], end_t=self.end_time, end_value=0.0)\n l_a *= coeff\n f_a *= coeff\n if coeff is 0.0:\n self._stay_still = True\n start_coeff = self._evaluate_gait_stage_coeff(t, [0.0])\n l_a *= start_coeff\n f_a *= start_coeff\n l_extension = l_a * math.cos(2 * math.pi / period * t)\n f_extension = f_a * math.cos(2 * math.pi / period * t)\n initial_pose = self.init_pose\n l_swing = -l_extension\n swing = -f_extension\n pose = np.array([0.0, l_extension + action[0], f_extension + action[1],\n 0.0, l_swing + action[2], swing + action[3],\n 0.0, l_swing + action[4], swing + action[5],\n 0.0, l_extension + action[6], f_extension + action[7]])\n signal = initial_pose + pose\n return signal\n\n def _transform_action_to_motor_command(self, action):\n if self._stay_still:\n return self.init_pose\n t = self.rex.GetTimeSinceReset()\n self._check_target_position(t)\n action = self._signal(t, action)\n action = super(RexWalkEnv, self)._transform_action_to_motor_command(action)\n return action\n\n def is_fallen(self):\n \"\"\"Decide whether the rex has fallen.\n\n If the up directions between the base and the world is large (the dot\n product is smaller than 0.85), the rex is considered fallen.\n\n Returns:\n Boolean value that indicates whether the rex has fallen.\n \"\"\"\n orientation = self.rex.GetBaseOrientation()\n rot_mat = self._pybullet_client.getMatrixFromQuaternion(orientation)\n local_up = rot_mat[6:]\n return np.dot(np.asarray([0, 0, 1]), np.asarray(local_up)) < 0.85\n\n def _get_true_observation(self):\n \"\"\"Get the true observations of this environment.\n\n It includes the roll, the error between current pitch and desired pitch,\n roll dot and pitch dot of the base.\n\n Returns:\n The observation list.\n \"\"\"\n observation = []\n roll, pitch, _ = self.rex.GetTrueBaseRollPitchYaw()\n roll_rate, pitch_rate, _ = self.rex.GetTrueBaseRollPitchYawRate()\n observation.extend([roll, pitch, roll_rate, pitch_rate])\n self._true_observation = np.array(observation)\n return self._true_observation\n\n def _get_observation(self):\n observation = []\n roll, pitch, _ = self.rex.GetBaseRollPitchYaw()\n roll_rate, pitch_rate, _ = self.rex.GetBaseRollPitchYawRate()\n observation.extend([roll, pitch, roll_rate, pitch_rate])\n self._observation = np.array(observation)\n return self._observation\n\n def _get_observation_upper_bound(self):\n \"\"\"Get the upper bound of the observation.\n\n Returns:\n The upper bound of an observation. See GetObservation() for the details\n of each element of an observation.\n \"\"\"\n upper_bound = np.zeros(self._get_observation_dimension())\n upper_bound[0:2] = 2 * math.pi # Roll, pitch, yaw of the base.\n upper_bound[2:4] = 2 * math.pi / self._time_step # Roll, pitch, yaw rate.\n return upper_bound\n\n def _get_observation_lower_bound(self):\n lower_bound = -self._get_observation_upper_bound()\n return lower_bound\n" ]

[ [ "numpy.asarray", "numpy.array" ] ]

cabbagerice/word-chain

[ "5d2978df61a7136f502b1b601213e97454103e1e" ]

[ "kakunin.py" ]

[ "import firebase_admin\nfrom firebase_admin import credentials\nfrom firebase_admin import db\nfrom numpy import random as unko\nimport math\n\n\n#認証ファイルPATH\ncertificate_json_path='secret.json'\n#DBとアプリへの認証\nif (not len(firebase_admin._apps)):\n\tcred = credentials.Certificate(certificate_json_path) \n\tdefault_app = firebase_admin.initialize_app(cred, {\n\t'databaseURL': 'https://wordchain-bfb8b.firebaseio.com/'\n\t})\nprint(db.reference(\"/PDD_hum/あ/\"+ str(math.floor(unko.rand()*1000))).get());exit()" ]

[ [ "numpy.random.rand" ] ]

weihao94/keras-YOLOv3-model-set

[ "7b54809d5f5513a41a191289625612d71056e3ec" ]

[ "yolo2/models/layers.py" ]

[ "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nCommon layer definition for YOLOv2 models building\n\"\"\"\nfrom functools import wraps, reduce, partial\n\nimport tensorflow.keras.backend as K\nfrom tensorflow.keras.layers import Conv2D, DepthwiseConv2D, MaxPooling2D, Concatenate, Lambda\nfrom tensorflow.keras.layers import LeakyReLU\nfrom tensorflow.keras.layers import BatchNormalization\nfrom tensorflow.keras.regularizers import l2\n\nfrom common.backbones.layers import CustomBatchNormalization\n\n# Partial wrapper for Convolution2D with static default argument.\n_DarknetConv2D = partial(Conv2D, padding='same')\n\n\ndef compose(*funcs):\n \"\"\"Compose arbitrarily many functions, evaluated left to right.\n\n Reference: https://mathieularose.com/function-composition-in-python/\n \"\"\"\n # return lambda x: reduce(lambda v, f: f(v), funcs, x)\n if funcs:\n return reduce(lambda f, g: lambda *a, **kw: g(f(*a, **kw)), funcs)\n else:\n raise ValueError('Composition of empty sequence not supported.')\n\n\n@wraps(Conv2D)\ndef DarknetConv2D(*args, **kwargs):\n \"\"\"Wrapper to set Darknet weight regularizer for Convolution2D.\"\"\"\n darknet_conv_kwargs = {'kernel_regularizer': l2(5e-4)}\n darknet_conv_kwargs.update(kwargs)\n return _DarknetConv2D(*args, **darknet_conv_kwargs)\n\n@wraps(DepthwiseConv2D)\ndef DarknetDepthwiseConv2D(*args, **kwargs):\n \"\"\"Wrapper to set Darknet parameters for Convolution2D.\"\"\"\n darknet_conv_kwargs = {'kernel_regularizer': l2(5e-4)}\n darknet_conv_kwargs['padding'] = 'valid' if kwargs.get('strides')==(2,2) else 'same'\n darknet_conv_kwargs.update(kwargs)\n return DepthwiseConv2D(*args, **darknet_conv_kwargs)\n\n\ndef Darknet_Depthwise_Separable_Conv2D_BN_Leaky(filters, kernel_size=(3, 3), block_id_str=None, **kwargs):\n \"\"\"Depthwise Separable Convolution2D.\"\"\"\n if not block_id_str:\n block_id_str = str(K.get_uid())\n no_bias_kwargs = {'use_bias': False}\n no_bias_kwargs.update(kwargs)\n return compose(\n DarknetDepthwiseConv2D(kernel_size, name='conv_dw_' + block_id_str, **no_bias_kwargs),\n CustomBatchNormalization(name='conv_dw_%s_bn' % block_id_str),\n LeakyReLU(alpha=0.1, name='conv_dw_%s_leaky_relu' % block_id_str),\n Conv2D(filters, (1,1), padding='same', use_bias=False, strides=(1, 1), name='conv_pw_%s' % block_id_str),\n CustomBatchNormalization(name='conv_pw_%s_bn' % block_id_str),\n LeakyReLU(alpha=0.1, name='conv_pw_%s_leaky_relu' % block_id_str))\n\n\ndef Depthwise_Separable_Conv2D_BN_Leaky(filters, kernel_size=(3, 3), block_id_str=None):\n \"\"\"Depthwise Separable Convolution2D.\"\"\"\n if not block_id_str:\n block_id_str = str(K.get_uid())\n return compose(\n DepthwiseConv2D(kernel_size, padding='same', name='conv_dw_' + block_id_str),\n CustomBatchNormalization(name='conv_dw_%s_bn' % block_id_str),\n LeakyReLU(alpha=0.1, name='conv_dw_%s_leaky_relu' % block_id_str),\n Conv2D(filters, (1,1), padding='same', use_bias=False, strides=(1, 1), name='conv_pw_%s' % block_id_str),\n CustomBatchNormalization(name='conv_pw_%s_bn' % block_id_str),\n LeakyReLU(alpha=0.1, name='conv_pw_%s_leaky_relu' % block_id_str))\n\n\ndef DarknetConv2D_BN_Leaky(*args, **kwargs):\n \"\"\"Darknet Convolution2D followed by CustomBatchNormalization and LeakyReLU.\"\"\"\n no_bias_kwargs = {'use_bias': False}\n no_bias_kwargs.update(kwargs)\n return compose(\n DarknetConv2D(*args, **no_bias_kwargs),\n CustomBatchNormalization(),\n LeakyReLU(alpha=0.1))\n\n\ndef bottleneck_block(outer_filters, bottleneck_filters):\n \"\"\"Bottleneck block of 3x3, 1x1, 3x3 convolutions.\"\"\"\n return compose(\n DarknetConv2D_BN_Leaky(outer_filters, (3, 3)),\n DarknetConv2D_BN_Leaky(bottleneck_filters, (1, 1)),\n DarknetConv2D_BN_Leaky(outer_filters, (3, 3)))\n\n\ndef bottleneck_x2_block(outer_filters, bottleneck_filters):\n \"\"\"Bottleneck block of 3x3, 1x1, 3x3, 1x1, 3x3 convolutions.\"\"\"\n return compose(\n bottleneck_block(outer_filters, bottleneck_filters),\n DarknetConv2D_BN_Leaky(bottleneck_filters, (1, 1)),\n DarknetConv2D_BN_Leaky(outer_filters, (3, 3)))\n\n\ndef space_to_depth_x2(x):\n \"\"\"Thin wrapper for Tensorflow space_to_depth with block_size=2.\"\"\"\n # Import currently required to make Lambda work.\n # See: https://github.com/fchollet/keras/issues/5088#issuecomment-273851273\n import tensorflow as tf\n return tf.nn.space_to_depth(x, block_size=2)\n\n\ndef space_to_depth_x2_output_shape(input_shape):\n \"\"\"Determine space_to_depth output shape for block_size=2.\n\n Note: For Lambda with TensorFlow backend, output shape may not be needed.\n \"\"\"\n return (input_shape[0], input_shape[1] // 2, input_shape[2] // 2, 4 *\n input_shape[3]) if input_shape[1] else (input_shape[0], None, None,\n 4 * input_shape[3])\n\ndef yolo2_predictions(feature_maps, feature_channel_nums, num_anchors, num_classes):\n f1, f2 = feature_maps\n f1_channel_num, f2_channel_num = feature_channel_nums\n\n x1 = compose(\n DarknetConv2D_BN_Leaky(f1_channel_num, (3, 3)),\n DarknetConv2D_BN_Leaky(f1_channel_num, (3, 3)))(f1)\n\n # Here change the f2 channel number to f2_channel_num//8 first,\n # then expand back to f2_channel_num//2 with \"space_to_depth_x2\"\n x2 = DarknetConv2D_BN_Leaky(f2_channel_num//8, (1, 1))(f2)\n # TODO: Allow Keras Lambda to use func arguments for output_shape?\n x2_reshaped = Lambda(\n space_to_depth_x2,\n output_shape=space_to_depth_x2_output_shape,\n name='space_to_depth')(x2)\n\n x = Concatenate()([x2_reshaped, x1])\n x = DarknetConv2D_BN_Leaky(f1_channel_num, (3, 3))(x)\n y = DarknetConv2D(num_anchors * (num_classes + 5), (1, 1), name='predict_conv')(x)\n\n return y\n\n\ndef yolo2lite_predictions(feature_maps, feature_channel_nums, num_anchors, num_classes):\n f1, f2 = feature_maps\n f1_channel_num, f2_channel_num = feature_channel_nums\n\n x1 = compose(\n Depthwise_Separable_Conv2D_BN_Leaky(filters=f1_channel_num, kernel_size=(3, 3), block_id_str='pred_1'),\n Depthwise_Separable_Conv2D_BN_Leaky(filters=f1_channel_num, kernel_size=(3, 3), block_id_str='pred_2'))(f1)\n\n # Here change the f2 channel number to f2_channel_num//8 first,\n # then expand back to f2_channel_num//2 with \"space_to_depth_x2\"\n x2 = DarknetConv2D_BN_Leaky(f2_channel_num//8, (1, 1))(f2)\n # TODO: Allow Keras Lambda to use func arguments for output_shape?\n x2_reshaped = Lambda(\n space_to_depth_x2,\n output_shape=space_to_depth_x2_output_shape,\n name='space_to_depth')(x2)\n\n x = Concatenate()([x2_reshaped, x1])\n x = Depthwise_Separable_Conv2D_BN_Leaky(filters=f1_channel_num, kernel_size=(3, 3), block_id_str='pred_3')(x)\n y = DarknetConv2D(num_anchors * (num_classes + 5), (1, 1), name='predict_conv')(x)\n\n return y\n\n" ]

[ [ "tensorflow.keras.layers.DepthwiseConv2D", "tensorflow.keras.layers.Concatenate", "tensorflow.keras.layers.LeakyReLU", "tensorflow.keras.layers.Lambda", "tensorflow.keras.regularizers.l2", "tensorflow.keras.layers.Conv2D", "tensorflow.nn.space_to_depth", "tensorflow.keras.backend.get_uid" ] ]

mxndrwgrdnr/evictions

[ "bf59bfe98903c2aa839daf7597951dc36cdecaad" ]

[ "scripts/get_assessor_data.py" ]

[ "#######################################################\n# script to compile and standardize raw assessor data #\n#######################################################\n\n\nimport pandas as pd\nfrom tqdm import tqdm\nfrom geopy.geocoders import Nominatim\nfrom geopy.extra.rate_limiter import RateLimiter\nimport numpy as np\nimport geopandas as gpd\nfrom matplotlib import pyplot as plt\n\n# only use 10 years of history\nfiles = [\n # '../data/2019.8.12__SF_ASR_Secured_Roll_Data_2017-2018_0.xlsx',\n '../data/2019.8.12__SF_ASR_Secured_Roll_Data_2016-2017_0.xlsx',\n '../data/2019.8.12__SF_ASR_Secured_Roll_Data_2015-2016_0.xlsx',\n '../data/2019.8.20__SF_ASR_Secured_Roll_Data_2014-2015.xlsx',\n '../data/2019.8.20__SF_ASR_Secured_Roll_Data_2013-2014.xlsx',\n '../data/2019.8.20__SF_ASR_Secured_Roll_Data_2012-2013.xlsx',\n '../data/2019.8.20__SF_ASR_Secured_Roll_Data_2011-2012.xlsx',\n '../data/2019.8.20__SF_ASR_Secured_Roll_Data_2010-2011.xlsx',\n '../data/2019.8.20__SF_ASR_Secured_Roll_Data_2009-2010.xlsx',\n '../data/2019.8.20__SF_ASR_Secured_Roll_Data_2008-2009.xlsx',\n '../data/2019.8.20__SF_ASR_Secured_Roll_Data_2007-2008.xlsx',\n]\n\nyears = [\n # 2017,\n 2016, 2015, 2014, 2013, 2012, 2011, 2010, 2009, 2008, 2007]\n\nasr = pd.DataFrame()\n\nfor i, f in tqdm(enumerate(files), total=len(files)):\n\n tmp = pd.read_excel(f, engine='openpyxl')\n tmp['asr_yr'] = years[i]\n asr = pd.concat((asr, tmp), sort=True)\n\ncodes = pd.read_csv('../data/Reference__Assessor-Recorder_Property_Class_Codes.csv')\ncode_dict = dict(zip(codes['Class Code'], codes['Use Code']))\nrc_dict = dict(zip(codes['Class Code'], codes['rc_eligible'])) \n\nasr['use_code'] = asr['RP1CLACDE'].map(code_dict)\nasr['rc_eligible'] = asr['RP1CLACDE'].map(rc_dict)\nasr.loc[asr['RP1PRCLID'].isin(['1530 035', '1530 036']), 'PROPLOC'] = '0411 0409 14TH AV0000'\nasr.loc[asr['RP1PRCLID'].isin(['1432 061', '1432 060']), 'PROPLOC'] = '0355 0353 ARGUELLO BL0000'\nasr.loc[asr['RP1PRCLID'].isin(['1744 031', '1744 032']), 'PROPLOC'] = '0506 0504 HUGO ST0000'\nasr.loc[asr['RP1PRCLID'].isin(['1254 098', '1254 097']), 'PROPLOC'] = '0083 0081 DOWNEY ST0000'\nasr.loc[asr['RP1PRCLID'].isin(['0942 051', '0942 052']), 'PROPLOC'] = '2794 2792 FILBERT ST0000'\nasr.loc[asr['RP1PRCLID'] == '1187 016', 'PROPLOC'] = '0000 0048 ASHBURY ST0000'\nasr.loc[asr['RP1PRCLID'] == '1187 017', 'PROPLOC'] = '0000 0050 ASHBURY ST0000'\nasr.loc[asr['RP1PRCLID'].isin(\n ['3730 188', '3730 189', '3730 190', '3730 191', '3730 192']), 'PROPLOC'] = '0000 0019 RAUSCH ST0000'\nasr.loc[asr['RP1PRCLID'] == '3630 031', 'PROPLOC'] = '0175 0175 CHATTANOOGA ST0000'\nasr.loc[asr['RP1PRCLID'] == '3630 032', 'PROPLOC'] = '0177 0177 CHATTANOOGA ST0000'\nasr.loc[asr['RP1PRCLID'] == '3630 033', 'PROPLOC'] = '0179 0179 CHATTANOOGA ST0000'\nasr.loc[asr['RP1PRCLID'] == '3630 030', 'PROPLOC'] = '0173 0173 CHATTANOOGA ST0000'\nasr.loc[asr['RP1PRCLID'] == '3731 242', 'PROPLOC'] = '0000 0038 MOSS ST0000'\n\n\nasr = asr[asr['PROPLOC'] != '0000 0000 0000']\n\nasr['house_1'] = asr['PROPLOC'].str[0:4].str.lstrip('0')\nasr['house_2'] = asr['PROPLOC'].str[5:9].str.lstrip('0')\n\nasr['house_1'] = asr['house_1'].str.replace('\\D', '')\nasr.loc[asr['house_1'] == '', 'house_1'] = -999\nasr['house_2'] = asr['house_2'].str.replace('\\D', '')\n\nasr = asr[asr['house_2'] != '']\nasr = asr[~asr['PROPLOC'].str.contains('SITUS TO BE ASSIGNED')]\n\nasr['street_name'] = asr['PROPLOC'].str[10:].str.strip().str.split(' ').str[:-1].str.join(' ').str.strip().str.lstrip('0')\nasr['street_rest'] = asr['PROPLOC'].str[10:].str.strip().str.split(' ').str[-1].str.strip()\n\nasr['street_type'] = None\nasr['unit_num'] = None\n\nasr.loc[asr['street_rest'].str.len().isin([6, 7]), 'street_type'] = asr.loc[\n asr['street_rest'].str.len().isin([6, 7]), 'street_rest'].str[0:2]\nasr.loc[asr['street_rest'].str.len().isin([6, 7]), 'unit_num'] = asr.loc[\n asr['street_rest'].str.len().isin([6, 7]), 'street_rest'].str[2:]\nasr.loc[asr['street_rest'].str.len().isin([4, 5]), 'unit_num'] = asr.loc[\n asr['street_rest'].str.len().isin([4, 5]), 'street_rest']\n\nasr.loc[asr['PROPLOC'].str.contains(\n 'NORTH POINT'), 'street_name'] = 'NORTH POINT'\nasr.loc[asr['PROPLOC'].str.contains(\n 'NORTH POINT'), 'street_type'] = 'ST'\n\nasr.loc[asr['street_name'].str.contains('\\sAVE$|\\sAVENUE$|\\sSTREET$|\\sST$'), 'street_type'] = asr.loc[\n asr['street_name'].str.contains('\\sAVE$|\\sAVENUE$|\\sSTREET$|\\sST$'),\n 'street_name'].str.extract('(\\sAVE$|\\sAVENUE$|\\sSTREET$|\\sST$)', expand=False).str.strip().str[0:2]\nasr.loc[asr['street_name'].str.contains('\\sAVE$|\\sAVENUE$|\\sSTREET$|\\sST$'), 'street_name'] = asr.loc[\n asr['street_name'].str.contains('\\sAVE$|\\sAVENUE$|\\sSTREET$|\\sST$'), 'street_name'].str.split(\n '\\sAVE$|\\sAVENUE$|\\sSTREET$|\\sST$').str[0]\n\nasr.loc[(~pd.isnull(asr['street_name'])) & (asr['street_name'].str.contains(\n '\\sSTT$|\\sSTIT$|\\sSTITE$|\\sSTNIT$')), 'street_type'] = 'street'\nasr.loc[(~pd.isnull(asr['street_name'])) & (asr['street_name'].str.contains('\\sSTT$|\\sSTIT$|\\sSTITE$|\\sSTNIT$')), 'street_name'] = asr.loc[\n (~pd.isnull(asr['street_name'])) & \n (asr['street_name'].str.contains('\\sSTT$|\\sSTIT$|\\sSTITE$|\\sSTNIT$')), 'street_name'].str.split(\n '\\sSTT$|\\sSTIT$|\\sSTITE$|\\sSTNIT$').str[0].str.strip()\n\nasr.loc[asr['street_name'].str.contains('\\sNOR$'), 'street_type'] = 'BLVD'\nasr.loc[asr['street_name'].str.contains('FARRELL'), 'street_name'] = 'OFARRELL'\nasr.loc[asr['street_name'] == 'EDINBURG', 'street_name'] = 'EDINBURGH'\nasr.loc[asr['street_name'] == 'EDINBURG', 'street_type'] = 'ST'\nasr.loc[asr['PROPLOC'].str.contains('.*SO.*VAN NESS.*'), 'street_name'] = 'SOUTH VAN NESS'\nasr.loc[asr['PROPLOC'].str.contains('.*SO.*VAN NESS.*'), 'street_type'] = 'AVE'\nasr.loc[asr['PROPLOC'].str.contains('BROADWAY'), 'street_type'] = 'ST'\n\n# for pre in ['A', 'B', 'C']:\n# for street in ['COLLINGWOOD', 'HAYES', 'MASONIC', 'RODGERS']:\n# asr.loc[asr['street_name'] == pre + street, 'street_name'] = street\n# for pre in ['A', 'B']:\n# for street in [\n# # 'CHURCH', 'UPPER', '14TH', 'FOLSOM', 'PINE', 'FREDERICK', 'PROSPECT', 'HARPER', 'PARNASSUS',\n# # 'MACONDRAY',\n# 'STANYAN']:\n# asr.loc[asr['street_name'] == pre + street, 'street_name'] = street\n# for pre in ['A']:\n# for street in ['DOWNEY', 'CLINTON PARK']:\n# asr.loc[asr['street_name'] == pre + street, 'street_name'] = street\n\n# many streets have 4 digit street numbers with trailing zeros not present in the eviction records\n\n# asr.loc[(asr['street_name'] == 'FREDERICK') & (asr['house_2'].astype(str).str.len() == 4), 'house_2'] = \\\n# asr.loc[(asr['street_name'] == 'FREDERICK') & (asr['house_2'].astype(str).str.len() == 4), 'house_2'].str[0:3]\n# asr.loc[(asr['street_name'] == 'FREDERICK') & (asr['house_1'].astype(str).str.len() == 4), 'house_1'] = \\\n# asr.loc[(asr['street_name'] == 'FREDERICK') & (asr['house_1'].astype(str).str.len() == 4), 'house_1'].str[0:3]\n# asr.loc[(asr['street_name'] == 'DOWNEY') & (asr['house_2'].astype(str).str.len() == 4), 'house_2'] = \\\n# asr.loc[(asr['street_name'] == 'DOWNEY') & (asr['house_2'].astype(str).str.len() == 4), 'house_2'].str[0:3]\n# asr.loc[(asr['street_name'] == 'BELVEDERE') & (asr['house_2'].astype(str).str.len() == 4), 'house_2'] = \\\n# asr.loc[(asr['street_name'] == 'BELVEDERE') & (asr['house_2'].astype(str).str.len() == 4), 'house_2'].str[0:3]\n# asr.loc[(asr['street_name']=='SHRADER') & (asr['house_2'] > 2000) & (asr['house_2'].astype(str).str[-1] == '0'), 'house_2'] = \\\n# asr.loc[(asr['street_name']=='SHRADER') & (asr['house_2'] > 2000) & (asr['house_2'].astype(str).str[-1] == '0'), 'house_2'].str[0:3]\n# asr.loc[(asr['street_name']=='SHRADER') & (asr['house_1'] > 2000) & (asr['house_1'].astype(str).str[-1] == '0'), 'house_1'] = \\\n# asr.loc[(asr['street_name']=='SHRADER') & (asr['house_1'] > 2000) & (asr['house_1'].astype(str).str[-1] == '0'), 'house_1'].str[0:3]\n# asr.loc[(asr['street_name']=='WALLER') & (asr['house_2'] > 1000) & (asr['house_2'].astype(str).str[-1] == '0'), 'house_2'] = \\\n# asr.loc[(asr['street_name']=='WALLER') & (asr['house_2'] > 1000) & (asr['house_2'].astype(str).str[-1] == '0'), 'house_2'].str[0:3]\n# asr.loc[(asr['street_name']=='WALLER') & (asr['house_1'] > 1000) & (asr['house_1'].astype(str).str[-1] == '0'), 'house_1'] = \\\n# asr.loc[(asr['street_name']=='WALLER') & (asr['house_1'] > 1000) & (asr['house_1'].astype(str).str[-1] == '0'), 'house_1'].str[0:3]\n\nasr.loc[asr['street_name'].str.contains('^VALLEY.*F$'), 'street_name'] = 'VALLEY'\n\n# # a bunch of street names have an erroneous letter \"V\" appended to the beginning\n# asr.loc[(~pd.isnull(asr['street_name'])) & (asr['street_name'].str.contains('^V[^AEIOU]')), 'street_name'] = \\\n# asr.loc[(~pd.isnull(asr['street_name'])) & (asr['street_name'].str.contains('^V[^AEIOU]')), 'street_name'].str[1:]\n# other_weird_vnames = [\n# 'VELSIE', 'VUNDERWOOD', 'VEDGEHILL', 'VEGBERT', 'VOAKDALE', 'VANDOVER',\n# 'VINGERSON', 'VERVINE', 'VEDDY', 'VEVANS', 'VUNION', 'VALEMANY',\n# 'VARMSTRONG', 'VELMIRA', 'VIRVING', 'VOCEAN', 'VESMERALDA', 'VELLSWORTH',\n# 'VORIZABA', 'VALABAMA', 'VARGUELLO', 'VATHENS', 'VOAK', 'VELLIS',\n# 'VORTEGA', 'VALBERTA', 'VUPPER', 'VINGALLS', 'VELIZABETH', 'VARBOR',\n# 'VINDIANA', 'VUNIVERSITY', 'VEUCALYPTUS', 'VAPOLLO', 'VULLOA', 'VALADDIN',\n# 'VEATON', 'VEDGEWOOD', 'VERIE', 'VAQUAVISTA', 'VALTA', 'VALTON', 'VOTSEGO',\n# 'VORD', 'VAPTOS', 'VEXETER', 'VOCTAVIA', 'VURBANO', 'VAGNON', 'VOGDEN',\n# 'VASHTON', 'VAUSTIN', 'VASHBURY', 'VABBEY', 'VALDER', 'VARKANSAS',\n# 'VOAK GROVE', 'VARCH', 'VEDGAR', 'VILLINOIS', 'VARLETA']\n# asr.loc[asr['street_name'].isin(other_weird_vnames), 'street_name'] = \\\n# asr.loc[asr['street_name'].isin(other_weird_vnames), 'street_name'].str[1:]\n\nst_typ_dict = {'street': 'ST', 'AV': 'AVE', 'BL': 'BLVD', 'WY': 'WAY',\n 'TE': 'TER', 'PK': 'PARK', 'HW': 'HWY', 'LANE': 'LN', 'AL': 'ALY',\n 'CR': 'CIR', 'LA': 'LN', 'PZ': 'PLZ', 'TR': 'TER', 'RW': 'ROW', 'BV': 'BLVD',\n 'WK': 'WALK'}\nasr = asr.replace({'street_type': st_typ_dict})\n\n\nbldg_typ_dict = {'SRES': 1, 'GOVT': 2, 'IND': 3, 'COMM': 4,\n 'COMR': 5, 'COMO': 6, 'COMH': 7, 'MISC': 8, 'MRES': 9}\n\nasr['bldg_type'] = asr.replace({'use_code': bldg_typ_dict})['use_code']\n\n#\n\nasr.to_csv('../data/assessor_2007-2016.csv', index=False)" ]

[ [ "pandas.concat", "pandas.read_excel", "pandas.read_csv", "pandas.isnull", "pandas.DataFrame" ] ]

MaximumEntropy/pytorch-lightning

[ "d8c501b22bc2c02a4bedb8b686daa5f904d6cf23" ]

[ "pytorch_lightning/trainer/data_loading.py" ]

[ "# Copyright The PyTorch Lightning team.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\nimport inspect\nimport multiprocessing\nimport os\nfrom abc import ABC\nfrom copy import deepcopy\nfrom functools import partial\nfrom typing import Any, Callable, Dict, List, Optional, Tuple, Union\n\nfrom torch.utils.data import BatchSampler, DataLoader, RandomSampler, Sampler, SequentialSampler\nfrom torch.utils.data.dataset import IterableDataset\nfrom torch.utils.data.distributed import DistributedSampler\n\nimport pytorch_lightning as pl\nfrom pytorch_lightning.accelerators import Accelerator\nfrom pytorch_lightning.overrides.distributed import IndexBatchSamplerWrapper, UnrepeatedDistributedSampler\nfrom pytorch_lightning.trainer.connectors.accelerator_connector import AcceleratorConnector\nfrom pytorch_lightning.trainer.states import RunningStage\nfrom pytorch_lightning.trainer.supporters import CombinedLoader\nfrom pytorch_lightning.utilities import rank_zero_warn\nfrom pytorch_lightning.utilities.apply_func import apply_to_collection\nfrom pytorch_lightning.utilities.auto_restart import (\n _capture_metadata_collate,\n CaptureIterableDataset,\n CaptureMapDataset,\n FastForwardSampler,\n)\nfrom pytorch_lightning.utilities.data import has_iterable_dataset, has_len\nfrom pytorch_lightning.utilities.exceptions import MisconfigurationException\nfrom pytorch_lightning.utilities.imports import _fault_tolerant_training\nfrom pytorch_lightning.utilities.model_helpers import is_overridden\nfrom pytorch_lightning.utilities.seed import pl_worker_init_function\n\n\nclass TrainerDataLoadingMixin(ABC):\n\n # this is just a summary on variables used in this abstract class,\n # the proper values/initialisation should be done in child class\n val_check_interval: float\n tpu_local_core_rank: int\n train_dataloader: DataLoader\n num_training_batches: Union[int, float]\n val_check_batch: float\n val_dataloaders: Optional[List[DataLoader]]\n num_val_batches: List[Union[int, float]]\n test_dataloaders: Optional[List[DataLoader]]\n num_test_batches: List[Union[int, float]]\n limit_train_batches: Union[int, float]\n log_every_n_steps: int\n overfit_batches: Union[int, float]\n distributed_sampler_kwargs: dict\n accelerator: Accelerator\n accelerator_connector: AcceleratorConnector\n call_hook: Callable\n\n def _worker_check(self, dataloader: DataLoader, name: str) -> None:\n if not isinstance(dataloader, DataLoader):\n return\n\n using_spawn = self.accelerator_connector.distributed_backend == \"ddp_spawn\"\n num_cpus = multiprocessing.cpu_count()\n\n # ddp_spawn + num_workers > 0 don't mix! tell the user\n if dataloader.num_workers > 0 and using_spawn:\n # checks for the attr persistent_workers available in pytorch >= 1.7\n if hasattr(dataloader, \"persistent_workers\"):\n if not dataloader.persistent_workers:\n rank_zero_warn(\n \"num_workers>0, persistent_workers=False, and accelerator=ddp_spawn\"\n \" may result in data loading bottlenecks.\"\n \" Consider setting persistent_workers=True\"\n \" (this is a limitation of Python .spawn() and PyTorch)\"\n )\n else:\n rank_zero_warn(\n \"num_workers>0 and accelerator=ddp_spawn do not mix well\"\n \" and may result in data loading bottlenecks.\"\n \" Consider setting accelerator=ddp to use num_workers>0\"\n \" (this is a limitation of Python .spawn() and PyTorch)\"\n )\n\n elif dataloader.num_workers == 0 and using_spawn:\n # checks for the attr persistent_workers available in pytorch >= 1.7\n if hasattr(dataloader, \"persistent_workers\"):\n if not dataloader.persistent_workers:\n rank_zero_warn(\n \"accelerator=ddp_spawn and num_workers=0 may result in data loading bottlenecks.\"\n \" Consider setting num_workers>0 and persistent_workers=True\"\n )\n else:\n rank_zero_warn(\n \"accelerator=ddp_spawn and num_workers=0 may result in data loading bottlenecks.\"\n \" Consider setting accelerator=ddp and set num_workers>0\"\n )\n\n elif dataloader.num_workers <= 2 < num_cpus and not using_spawn:\n rank_zero_warn(\n f\"The dataloader, {name}, does not have many workers which may be a bottleneck.\"\n \" Consider increasing the value of the `num_workers` argument`\"\n f\" (try {num_cpus} which is the number of cpus on this machine)\"\n \" in the `DataLoader` init to improve performance.\"\n )\n\n def auto_add_worker_init_fn(self, dataloader: DataLoader) -> None:\n if int(os.environ.get(\"PL_SEED_WORKERS\", 0)) and dataloader.worker_init_fn is None:\n dataloader.worker_init_fn = partial(pl_worker_init_function, rank=self.global_rank)\n\n def auto_add_sampler(self, dataloader: Any, shuffle: bool, mode: Optional[RunningStage] = None) -> Any:\n if isinstance(dataloader, CombinedLoader):\n # apply `auto_add_sampler` on all the collection of loaders\n dataloader.loaders = apply_to_collection(\n dataloader.loaders, DataLoader, self.auto_add_sampler, shuffle, mode=mode\n )\n return dataloader\n\n # don't do anything if it's not a dataloader\n if not isinstance(dataloader, DataLoader):\n return dataloader\n\n if (\n self.accelerator_connector.replace_sampler_ddp\n and self.accelerator_connector.is_distributed\n and not isinstance(dataloader.sampler, DistributedSampler)\n and not has_iterable_dataset(dataloader)\n ):\n if not isinstance(dataloader.sampler, (SequentialSampler, RandomSampler)):\n raise MisconfigurationException(\n \"You seem to have configured a sampler in your DataLoader. This will be replaced \"\n \" by `DistributedSampler` since `replace_sampler_ddp` is True and you are using\"\n \" distributed training. Either remove the sampler from your DataLoader or set\"\n \" `replace_sampler_ddp`=False if you want to use your custom sampler.\"\n )\n sampler = self._get_distributed_sampler(dataloader, shuffle, mode=mode)\n dataloader = self.replace_sampler(dataloader, sampler, mode=mode)\n else:\n # use current sampler\n sampler = dataloader.sampler\n\n return dataloader\n\n @staticmethod\n def _resolve_batch_sampler(\n dataloader: DataLoader, sampler: Optional[Sampler], mode: Optional[RunningStage] = None\n ) -> Dict[str, Any]:\n batch_sampler = getattr(dataloader, \"batch_sampler\")\n is_predicting = mode == RunningStage.PREDICTING\n # checking the batch sampler type is different than PyTorch default.\n if (batch_sampler is not None and type(batch_sampler) is not BatchSampler) or is_predicting:\n batch_sampler = type(batch_sampler)(\n sampler,\n batch_size=batch_sampler.batch_size,\n drop_last=(False if is_predicting else batch_sampler.drop_last),\n )\n if is_predicting:\n batch_sampler = IndexBatchSamplerWrapper(batch_sampler)\n\n if _fault_tolerant_training():\n fast_forward_sampler = batch_sampler = FastForwardSampler(batch_sampler)\n fast_forward_sampler.setup(dataloader_batch_size=1)\n\n return {\n \"sampler\": None,\n \"shuffle\": False,\n \"batch_sampler\": batch_sampler,\n \"batch_size\": 1,\n \"drop_last\": False,\n }\n\n if _fault_tolerant_training():\n fast_forward_sampler = sampler = FastForwardSampler(sampler)\n fast_forward_sampler.setup(dataloader_batch_size=dataloader.batch_size)\n\n return {\"sampler\": sampler, \"shuffle\": False, \"batch_sampler\": None}\n\n @staticmethod\n def _get_dataloader_init_kwargs(\n dataloader: DataLoader, sampler: Optional[Sampler], mode: Optional[RunningStage] = None\n ) -> Dict[str, Any]:\n if not isinstance(dataloader, DataLoader):\n raise ValueError(f\"The dataloader {dataloader} needs to subclass `torch.utils.data.DataLoader`\")\n\n # get the dataloader instance attributes\n attrs = {k: v for k, v in vars(dataloader).items() if not k.startswith(\"_\")}\n # not part of `vars`\n attrs[\"multiprocessing_context\"] = dataloader.multiprocessing_context\n\n # get the dataloader instance `__init__` parameters\n params = dict(inspect.signature(dataloader.__init__).parameters)\n has_variadic_kwargs = any(p.kind is p.VAR_KEYWORD for p in params.values())\n if has_variadic_kwargs:\n # if the signature takes **kwargs, assume they will be passed down with `super().__init__(**kwargs)`\n params.update(inspect.signature(DataLoader.__init__).parameters)\n del params[\"self\"]\n\n # keep only the params whose default is different to the current attr value\n non_defaults = {name for name, p in params.items() if name in attrs and p.default != attrs[name]}\n # add `dataset` as it might have been replaced with `*args`\n non_defaults.add(\"dataset\")\n\n # kwargs to re-construct the dataloader\n dl_kwargs = {k: v for k, v in attrs.items() if k in non_defaults}\n dl_kwargs.update(TrainerDataLoadingMixin._resolve_batch_sampler(dataloader, sampler, mode=mode))\n\n required_args = {\n p.name\n for p in params.values()\n if p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD)\n and p.default is p.empty\n and p.name not in dl_kwargs\n }\n # the dataloader has required args which we could not extract from the existing attributes\n if required_args:\n required_args = sorted(required_args)\n dataloader_cls_name = dataloader.__class__.__name__\n raise MisconfigurationException(\n f\"Trying to inject `DistributedSampler` into the `{dataloader_cls_name}` instance. \"\n \"This would fail as some of the `__init__` arguments are not available as instance attributes. \"\n f\"The missing attributes are {required_args}. \"\n f\"HINT: If you wrote the `{dataloader_cls_name}` class, define `self.missing_arg_name` or \"\n \"manually add the `DistributedSampler` as: \"\n f\"`{dataloader_cls_name}(dataset, sampler=DistributedSampler(dataset))`.\"\n )\n\n if not has_variadic_kwargs:\n # the dataloader signature does not allow keyword arguments that need to be passed\n missing_kwargs = dl_kwargs.keys() - params.keys()\n if missing_kwargs:\n missing_kwargs = sorted(missing_kwargs)\n dataloader_cls_name = dataloader.__class__.__name__\n raise MisconfigurationException(\n f\"Trying to inject `DistributedSampler` into the `{dataloader_cls_name}` instance. \"\n \"This would fail as it doesn't expose all its attributes in the `__init__` signature. \"\n f\"The missing arguments are {missing_kwargs}. \"\n f\"HINT: If you wrote the `{dataloader_cls_name}` class, add the `__init__` arguments or \"\n \"manually add the `DistributedSampler` as: \"\n f\"`{dataloader_cls_name}(dataset, sampler=DistributedSampler(dataset))`.\"\n )\n\n if isinstance(dl_kwargs[\"dataset\"], IterableDataset):\n dl_kwargs[\"batch_sampler\"] = None\n dl_kwargs[\"sampler\"] = None\n\n if _fault_tolerant_training():\n if isinstance(dl_kwargs[\"dataset\"], IterableDataset):\n # wrap the `IterableDataset` into a `CaptureIterableDataset` to record sampler states.\n dl_kwargs[\"dataset\"] = CaptureIterableDataset(dataset=dl_kwargs[\"dataset\"])\n elif len(dl_kwargs[\"dataset\"]):\n dl_kwargs[\"dataset\"] = CaptureMapDataset(dataset=dl_kwargs[\"dataset\"])\n else:\n raise MisconfigurationException(\n \"This shouldn't happen, please open an issue on Lightning Github repository.\"\n )\n\n return dl_kwargs\n\n @staticmethod\n def replace_sampler(dataloader: DataLoader, sampler, mode: Optional[RunningStage] = None) -> DataLoader:\n dl_kwargs = TrainerDataLoadingMixin._get_dataloader_init_kwargs(dataloader, sampler, mode=mode)\n dl_cls = type(dataloader)\n dataloader = dl_cls(**dl_kwargs)\n return dataloader\n\n def _get_distributed_sampler(\n self, dataloader: DataLoader, shuffle: bool, mode: Optional[RunningStage] = None\n ) -> DistributedSampler:\n kwargs = self.distributed_sampler_kwargs\n kwargs[\"shuffle\"] = shuffle and not self.overfit_batches\n kwargs.setdefault(\"seed\", int(os.getenv(\"PL_GLOBAL_SEED\", 0)))\n cls = UnrepeatedDistributedSampler if mode == RunningStage.PREDICTING else DistributedSampler\n sampler = cls(dataloader.dataset, **kwargs)\n return sampler\n\n def reset_train_dataloader(self, model: Optional[\"pl.LightningModule\"] = None) -> None:\n \"\"\"Resets the train dataloader and initialises required variables (number of batches, when to validate,\n etc.).\n\n Args:\n model: The `LightningModule` if calling this outside of the trainer scope.\n \"\"\"\n self.train_dataloader = self.request_dataloader(RunningStage.TRAINING, model=model)\n\n if self.overfit_batches > 0:\n if hasattr(self.train_dataloader, \"sampler\") and isinstance(self.train_dataloader.sampler, RandomSampler):\n rank_zero_warn(\n \"You requested to overfit but enabled training dataloader shuffling.\"\n \" We are turning off the training dataloader shuffling for you.\"\n )\n self.train_dataloader = self.replace_sampler(\n self.train_dataloader, SequentialSampler(self.train_dataloader.dataset), mode=RunningStage.TRAINING\n )\n\n # automatically add samplers\n self.train_dataloader = apply_to_collection(\n self.train_dataloader, DataLoader, self.auto_add_sampler, shuffle=True, mode=RunningStage.TRAINING\n )\n\n # check the workers recursively\n apply_to_collection(self.train_dataloader, DataLoader, self._worker_check, \"train_dataloader\")\n\n # add worker_init_fn for correct seeding in worker processes\n apply_to_collection(self.train_dataloader, DataLoader, self.auto_add_worker_init_fn)\n\n # add collate_fn to collect metadata for fault tolerant training\n if _fault_tolerant_training():\n apply_to_collection(self.train_dataloader, DataLoader, self._add_sampler_metadata_collate)\n\n # wrap the sequence of train loaders to a CombinedLoader object for computing the num_training_batches\n self.train_dataloader = CombinedLoader(self.train_dataloader, self.data_connector.multiple_trainloader_mode)\n\n self.num_training_batches = len(self.train_dataloader) if has_len(self.train_dataloader) else float(\"inf\")\n\n if isinstance(self.limit_train_batches, int) or self.limit_train_batches == 0.0:\n self.num_training_batches = min(self.num_training_batches, int(self.limit_train_batches))\n elif self.num_training_batches != float(\"inf\"):\n self.num_training_batches = int(self.num_training_batches * self.limit_train_batches)\n elif self.limit_train_batches != 1.0:\n raise MisconfigurationException(\n \"When using an IterableDataset for `limit_train_batches`,\"\n \" `Trainer(limit_train_batches)` must be `0.0`, `1.0` or an int. An int k specifies\"\n \" `num_training_batches` to use.\"\n )\n\n # determine when to check validation\n # if int passed in, val checks that often\n # otherwise, it checks in [0, 1.0] % range of a training epoch\n if isinstance(self.val_check_interval, int):\n self.val_check_batch = self.val_check_interval\n if self.val_check_batch > self.num_training_batches:\n raise ValueError(\n f\"`val_check_interval` ({self.val_check_interval}) must be less than or equal \"\n f\"to the number of the training batches ({self.num_training_batches}). \"\n \"If you want to disable validation set `limit_val_batches` to 0.0 instead.\"\n )\n else:\n if not has_len(self.train_dataloader):\n if self.val_check_interval == 1.0:\n self.val_check_batch = float(\"inf\")\n else:\n raise MisconfigurationException(\n \"When using an IterableDataset for `train_dataloader`,\"\n \" `Trainer(val_check_interval)` must be `1.0` or an int. An int k specifies\"\n \" checking validation every k training batches.\"\n )\n else:\n self.val_check_batch = int(self.num_training_batches * self.val_check_interval)\n self.val_check_batch = max(1, self.val_check_batch)\n\n if self.logger and self.num_training_batches < self.log_every_n_steps:\n rank_zero_warn(\n f\"The number of training samples ({self.num_training_batches}) is smaller than the logging interval\"\n f\" Trainer(log_every_n_steps={self.log_every_n_steps}). Set a lower value for log_every_n_steps if\"\n \" you want to see logs for the training epoch.\"\n )\n\n def _reset_eval_dataloader(\n self, mode: RunningStage, model: Optional[\"pl.LightningModule\"] = None\n ) -> Tuple[List[Union[int, float]], List[DataLoader]]:\n \"\"\"Generic method to reset a dataloader for evaluation.\n\n Args:\n mode: The running stage of the ``Trainer``\n model: The ``LightningModule`` if calling this outside of the trainer scope.\n\n Returns:\n Tuple (num_batches, dataloaders)\n \"\"\"\n assert mode.evaluating or mode == RunningStage.PREDICTING\n\n # always get the loaders first so we can count how many there are\n dataloaders = self.request_dataloader(mode, model=model)\n\n if not isinstance(dataloaders, list):\n dataloaders = [dataloaders]\n\n # when overfitting, use the training loader as val and test\n # duplicate it the numb of times needed to match the train loaders\n if self.overfit_batches > 0:\n train_dataloader = self.request_dataloader(RunningStage.TRAINING, model=model)\n dataloaders = [deepcopy(train_dataloader) for _ in range(len(dataloaders))]\n\n for loader_i in range(len(dataloaders)):\n loader = dataloaders[loader_i]\n\n if hasattr(loader, \"sampler\") and isinstance(loader.sampler, RandomSampler):\n\n # when overfitting, the dataloader should not have sampler\n if self.overfit_batches > 0 and mode.evaluating:\n rank_zero_warn(\n \"You requested to overfit but enabled val/test dataloader shuffling.\"\n \" We are turning it off for you.\"\n )\n dataloaders[loader_i] = self.replace_sampler(loader, SequentialSampler(loader.dataset), mode=mode)\n else:\n rank_zero_warn(\n f\"Your `{mode.dataloader_prefix}_dataloader` has `shuffle=True`,\"\n \"it is strongly recommended that you turn this off for val/test/predict dataloaders.\"\n )\n\n if any(dl is None for dl in dataloaders):\n rank_zero_warn(\"One of given dataloaders is None and it will be skipped.\")\n\n # add samplers\n dataloaders = [self.auto_add_sampler(dl, False, mode=mode) for dl in dataloaders if dl is not None]\n\n # add worker_init_fn for correct seeding in worker processes\n apply_to_collection(dataloaders, dtype=DataLoader, function=self.auto_add_worker_init_fn)\n\n loader_num_batches = []\n\n # determine number of batches\n # datasets could be none, 1 or 2+\n if len(dataloaders) != 0:\n for i, dataloader in enumerate(dataloaders):\n num_batches = len(dataloader) if has_len(dataloader) else float(\"inf\")\n self._worker_check(dataloader, f\"{mode.dataloader_prefix}_dataloader {i}\")\n\n # percent or num_steps\n limit_eval_batches = getattr(self, f\"limit_{mode.dataloader_prefix}_batches\")\n\n # limit num batches either as a percent or num steps\n if isinstance(limit_eval_batches, int) or limit_eval_batches == 0.0:\n num_batches = min(num_batches, int(limit_eval_batches))\n elif num_batches != float(\"inf\"):\n num_batches = int(num_batches * limit_eval_batches)\n elif limit_eval_batches != 1.0:\n raise MisconfigurationException(\n f\"When using an IterableDataset for `limit_{mode}_batches`,\"\n f\" `Trainer(limit_{mode.dataloader_prefix}_batches)` must be `0.0`, `1.0` or an int. An int k\"\n f\" specifies `num_{mode.dataloader_prefix}_batches` to use.\"\n )\n\n if num_batches == 0 and limit_eval_batches > 0.0 and isinstance(limit_eval_batches, float):\n min_pct = 1.0 / len(dataloader)\n raise MisconfigurationException(\n f\"you requested to check {limit_eval_batches} of the `{mode.dataloader_prefix}_dataloader` but\"\n f\" {limit_eval_batches}*{num_batches} < 1. Please increase the\"\n f\" `limit_{mode.dataloader_prefix}_batches` flag. Try at least\"\n f\" `limit_{mode.dataloader_prefix}_batches={min_pct}`\"\n )\n\n loader_num_batches.append(num_batches)\n\n return loader_num_batches, dataloaders\n\n def reset_val_dataloader(self, model: Optional[\"pl.LightningModule\"] = None) -> None:\n \"\"\"Resets the validation dataloader and determines the number of batches.\n\n Args:\n model: The `LightningModule` if called outside of the trainer scope.\n \"\"\"\n pl_module = self.lightning_module or model\n has_loader = is_overridden(\"val_dataloader\", pl_module)\n has_step = is_overridden(\"validation_step\", pl_module)\n if has_loader and has_step:\n self.num_val_batches, self.val_dataloaders = self._reset_eval_dataloader(\n RunningStage.VALIDATING, model=pl_module\n )\n\n def reset_test_dataloader(self, model: Optional[\"pl.LightningModule\"] = None) -> None:\n \"\"\"Resets the test dataloader and determines the number of batches.\n\n Args:\n model: The `LightningModule` if called outside of the trainer scope.\n \"\"\"\n pl_module = self.lightning_module or model\n has_loader = is_overridden(\"test_dataloader\", pl_module)\n has_step = is_overridden(\"test_step\", pl_module)\n if has_loader and has_step:\n self.num_test_batches, self.test_dataloaders = self._reset_eval_dataloader(\n RunningStage.TESTING, model=pl_module\n )\n\n def reset_predict_dataloader(self, model: Optional[\"pl.LightningModule\"] = None) -> None:\n \"\"\"Resets the predict dataloader and determines the number of batches.\n\n Args:\n model: The `LightningModule` if called outside of the trainer scope.\n \"\"\"\n pl_module = self.lightning_module or model\n has_loader = is_overridden(\"predict_dataloader\", pl_module)\n if has_loader:\n self.num_predict_batches, self.predict_dataloaders = self._reset_eval_dataloader(\n RunningStage.PREDICTING, model=pl_module\n )\n\n def reset_train_val_dataloaders(self, model: Optional[\"pl.LightningModule\"] = None) -> None:\n \"\"\"Resets train and val dataloaders if none are attached to the trainer.\n\n The val dataloader must be initialized before training loop starts, as the training loop\n inspects the val dataloader to determine whether to run the evaluation loop.\n\n Args:\n model: The `LightningModule` if called outside of the trainer scope.\n \"\"\"\n if self.train_dataloader is None:\n self.reset_train_dataloader(model=model)\n if self.val_dataloaders is None:\n self.reset_val_dataloader(model=model)\n\n def request_dataloader(\n self, stage: RunningStage, model: Optional[\"pl.LightningModule\"] = None\n ) -> Union[DataLoader, List[DataLoader]]:\n \"\"\"Handles downloading data in the GPU or TPU case.\n\n Returns:\n The dataloader\n \"\"\"\n hook = f\"{stage.dataloader_prefix}_dataloader\"\n self.call_hook(\"on_\" + hook, pl_module=model)\n dataloader = self.call_hook(hook, pl_module=model)\n if isinstance(dataloader, tuple):\n dataloader = list(dataloader)\n self.training_type_plugin.barrier(\"get_dataloaders\")\n return dataloader\n\n @staticmethod\n def _add_sampler_metadata_collate(dataloader: DataLoader) -> None:\n \"\"\"Wrap default collate function to retrive ``FastForwardSampler`` state dict when fault tolerant is\n enabled.\"\"\"\n dataloader.collate_fn = partial(\n _capture_metadata_collate, dataset=dataloader.dataset, default_collate=dataloader.collate_fn\n )\n" ]

[ [ "torch.utils.data.SequentialSampler" ] ]

egreen-park/crwusiz

[ "da528ebea9945f5a2a0a286467bb1c349aa7472f" ]

[ "selfdrive/controls/lib/lane_planner.py" ]

[ "from common.numpy_fast import interp\nimport numpy as np\nfrom selfdrive.hardware import EON, TICI\nfrom cereal import log\n\n\nTRAJECTORY_SIZE = 33\n# camera offset is meters from center car to camera\nif EON:\n CAMERA_OFFSET = 0.10\n PATH_OFFSET = 0.0\nelif TICI:\n CAMERA_OFFSET = -0.04\n PATH_OFFSET = -0.04\nelse:\n CAMERA_OFFSET = 0.0\n PATH_OFFSET = 0.0\n\n\nclass LanePlanner:\n def __init__(self, wide_camera=False):\n self.ll_t = np.zeros((TRAJECTORY_SIZE,))\n self.ll_x = np.zeros((TRAJECTORY_SIZE,))\n self.lll_y = np.zeros((TRAJECTORY_SIZE,))\n self.rll_y = np.zeros((TRAJECTORY_SIZE,))\n self.lane_width_estimate = 3.7\n self.lane_width_certainty = 1.0\n self.lane_width = 3.7\n\n self.lll_prob = 0.\n self.rll_prob = 0.\n self.d_prob = 0.\n\n self.lll_std = 0.\n self.rll_std = 0.\n\n self.l_lane_change_prob = 0.\n self.r_lane_change_prob = 0.\n\n self.camera_offset = -CAMERA_OFFSET if wide_camera else CAMERA_OFFSET\n self.path_offset = -PATH_OFFSET if wide_camera else PATH_OFFSET\n\n def parse_model(self, md):\n if len(md.laneLines) == 4 and len(md.laneLines[0].t) == TRAJECTORY_SIZE:\n self.ll_t = (np.array(md.laneLines[1].t) + np.array(md.laneLines[2].t))/2\n # left and right ll x is the same\n self.ll_x = md.laneLines[1].x\n # only offset left and right lane lines; offsetting path does not make sense\n self.lll_y = np.array(md.laneLines[1].y) - self.camera_offset\n self.rll_y = np.array(md.laneLines[2].y) - self.camera_offset\n self.lll_prob = md.laneLineProbs[1]\n self.rll_prob = md.laneLineProbs[2]\n self.lll_std = md.laneLineStds[1]\n self.rll_std = md.laneLineStds[2]\n\n if len(md.meta.desireState):\n self.l_lane_change_prob = md.meta.desireState[log.LateralPlan.Desire.laneChangeLeft]\n self.r_lane_change_prob = md.meta.desireState[log.LateralPlan.Desire.laneChangeRight]\n\n def get_d_path(self, v_ego, path_t, path_xyz):\n # Reduce reliance on lanelines that are too far apart or\n # will be in a few seconds\n path_xyz[:, 1] -= self.path_offset\n l_prob, r_prob = self.lll_prob, self.rll_prob\n width_pts = self.rll_y - self.lll_y\n prob_mods = []\n for t_check in [0.0, 1.5, 3.0]:\n width_at_t = interp(t_check * (v_ego + 7), self.ll_x, width_pts)\n prob_mods.append(interp(width_at_t, [4.0, 5.0], [1.0, 0.0]))\n mod = min(prob_mods)\n l_prob *= mod\n r_prob *= mod\n\n # Reduce reliance on uncertain lanelines\n l_std_mod = interp(self.lll_std, [.15, .3], [1.0, 0.0])\n r_std_mod = interp(self.rll_std, [.15, .3], [1.0, 0.0])\n l_prob *= l_std_mod\n r_prob *= r_std_mod\n\n # Find current lanewidth\n self.lane_width_certainty += 0.05 * (l_prob * r_prob - self.lane_width_certainty)\n current_lane_width = abs(self.rll_y[0] - self.lll_y[0])\n self.lane_width_estimate += 0.005 * (current_lane_width - self.lane_width_estimate)\n speed_lane_width = interp(v_ego, [0., 31.], [2.8, 3.5])\n self.lane_width = self.lane_width_certainty * self.lane_width_estimate + \\\n (1 - self.lane_width_certainty) * speed_lane_width\n\n clipped_lane_width = min(4.0, self.lane_width)\n path_from_left_lane = self.lll_y + clipped_lane_width / 2.0\n path_from_right_lane = self.rll_y - clipped_lane_width / 2.0\n\n self.d_prob = l_prob + r_prob - l_prob * r_prob\n lane_path_y = (l_prob * path_from_left_lane + r_prob * path_from_right_lane) / (l_prob + r_prob + 0.0001)\n lane_path_y_interp = np.interp(path_t, self.ll_t, lane_path_y)\n path_xyz[:,1] = self.d_prob * lane_path_y_interp + (1.0 - self.d_prob) * path_xyz[:,1]\n return path_xyz\n" ]

[ [ "numpy.array", "numpy.zeros", "numpy.interp" ] ]

cattech-lab/cantera_examples

[ "13e969b2a767bed5bb0d79adf86187cd9fbd090d" ]

[ "ic_engine.py" ]

[ "\"\"\"\nSimulation of a internal combustion engine.\n\"\"\"\n\nimport cantera as ct\nimport numpy as np\nimport csv\n\n#------------------------------------------------------\n# Input Parameters\nrpm = 600.0 # engine speed [rpm]\nbore = 82.55 # bore diameter [mm]\nstroke = 114.3 # stroke [mm]\ncratio = 10.0 # compression ratio [-]\nconrod = 200.0 # connecting rod [mm]\n\n# initial temperature, pressure, and equivalence ratio\nT_ini = 350.0 # [K]\np_ini = 1.0e5 # [Pa]\nphi = 0.33\n\n# outer temperature, pressure, and composition\nT_out = 300.0 # [K]\np_out = 1.0e5 # [Pa]\nc_out = 'O2:1.0, N2:3.76'\n\n# Reaction mechanism name\nreaction_mechanism = 'reduced_247.cti'\n\n# Simulation time\nca_start = -144.0 # start CA [deg]\nca_end = 180.0 # end CA [deg]\nca_step = 0.01 # step CA [deg]\nca_out = 0.2 # output CA [deg]\n\n#------------------------------------------------------\n# load reaction mechanism\ngas = ct.Solution(reaction_mechanism)\n\n# define initial state\ngas.TP = T_ini, p_ini\ngas.set_equivalence_ratio(phi, 'NC7H16', 'O2:1.0, N2:3.76')\nr = ct.IdealGasReactor(gas)\nsim = ct.ReactorNet([r])\ngas.TPX = T_out, p_out, c_out\nouter = ct.Reservoir(gas)\n\n# convert time to crank angle [rad]\nrps = rpm / 60.0\ndef crank_angle(t):\n return 2.0 * np.pi * rps * t + ca_start * np.pi / 180.0\n\n# set up IC engine parameters\nstroke *= 0.001\nbore *= 0.001\nconrod *= 0.001\narea = 0.25 * np.pi * bore * bore\nvol_h = stroke * area # volume cylinder\nvol_c = vol_h / (cratio - 1.0) # volume combustion dome\nca = crank_angle(0.0) # initial CA\nr_ca = stroke * 0.5 # crank radius\nvol_ini= (r_ca + conrod - (r_ca * np.cos(ca) + np.sqrt(conrod**2 - r_ca**2 * np.sin(ca)**2))) * area + vol_c\nr.volume = vol_ini # initial volume\n\n# set up piston \npiston = ct.Wall(outer, r)\npiston.area = area # piston area\ndef piston_speed(t):\n ca = crank_angle(t)\n return -2.0 * np.pi * rps * (r_ca * np.sin(ca) + r_ca**2 * np.sin(2.0 * ca) / 2.0 / np.sqrt(conrod**2 - r_ca**2 * np.sin(ca)**2))\npiston.set_velocity(piston_speed) # piston speed\n\n# set up time\nt_sim = (ca_end - ca_start) / rps / 360.0 # simulation time\nt_step = ca_step / rps / 360.0 # simulation time step\nt_out = ca_out / rps / 360.0 # simulation output time\nttt = 0.0\n\n# set up output data arrays\nstates = ct.SolutionArray(r.thermo)\nt = []\nheat_release_rate = []\n\n# output file\noutfile = open('ic_engine.csv', 'w', newline=\"\")\ncsvfile = csv.writer(outfile)\ncsvfile.writerow(['ca[deg]','P[bar]','T[K]','HR[J/deg]'])\n\n# do simulation\nfor t_i in np.arange(0, t_sim, t_step):\n sim.advance(t_i)\n\n # write output data\n if t_i >= ttt:\n ca = crank_angle(t_i) * 180.0 / np.pi\n t.append(ca)\n\n states.append(r.thermo.state)\n\n hr = -r.volume * ct.gas_constant * r.T * np.sum(gas.standard_enthalpies_RT * r.thermo.net_production_rates, 0)\n hr = hr * t_step / ca_step\n heat_release_rate.append(hr)\n\n csvfile.writerow([ca, r.thermo.P / 1.0e5, r.T, hr])\n ttt += t_out\n\noutfile.close()\n\n#------------------------------------------------------\n# Plot Results in matplotlib\nimport matplotlib.pyplot as plt\n\n# pressure\nfig1 = plt.figure()\nax1 = fig1.add_subplot()\nax1.plot(t, states.P / 1.0e5)\nax1.set_ylabel('P [bar]')\nax1.set_xlabel('CA [deg]')\nax1.set_xlim(-60, 60)\n\n# temperature\nfig2 = plt.figure()\nax2 = fig2.add_subplot()\nax2.plot(t, states.T)\nax2.set_ylabel('T [K]')\nax2.set_xlabel('CA [deg]')\nax2.set_xlim(-60, 60)\n\n# heat release rate\nfig3 = plt.figure()\nax3 = fig3.add_subplot()\nax3.plot(t, heat_release_rate)\nax3.set_ylabel('Heat release rate [J/deg]')\nax3.set_xlabel('CA [deg]')\nax3.set_xlim(-60, 60)\n\nplt.show()\n" ]

[ [ "numpy.arange", "numpy.cos", "numpy.sin", "matplotlib.pyplot.show", "numpy.sum", "matplotlib.pyplot.figure" ] ]

deKeijzer/SRON-DCGAN

[ "1ead827ebf549917435e6bc9ddd2d4d5951aa205" ]

[ "notebooks/model_v2_small.py" ]

[ "# General imports\nfrom __future__ import print_function\n#%matplotlib inline\nimport argparse\nimport os\nimport random\nimport torch\nimport torch.nn as nn\nimport torch.nn.parallel\nimport torch.backends.cudnn as cudnn\nimport torch.optim as optim\nimport torch.utils.data\nimport torchvision.datasets as dset\nimport torchvision.transforms as transforms\nimport torchvision.utils as vutils\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport matplotlib.animation as animation\nfrom IPython.display import HTML\n\nfrom keijzer_exogan import *\n\n\nclass Generator(nn.Module):\n def __init__(self, ngpu, nz=100, ngf=32, nc=1):\n super(Generator, self).__init__()\n self.ngpu = ngpu\n self.nz = nz\n self.nc = nc\n self.ngf = ngf\n \n \"\"\"\n where (in_channels, out_channels, \n kernel_size, stride=1, padding=0, output_padding=0, groups=1, bias=True, dilation=1)\n \"\"\"\n self.main = nn.Sequential(\n \n #1\n # input is Z (100,1,1), going into a convolution\n nn.ConvTranspose2d( nz, ngf * 16, 4, 1, 0, bias=False),\n nn.LeakyReLU(0.2, inplace=True), # Should use ReLU in generator according to DCGAN paper,\n #nn.Dropout2d(0.5),\n \n #2\n # state size. (ngf*8) x 4 x 4\n nn.ConvTranspose2d(ngf * 16, ngf * 8, 4, 2, 1, bias=False),\n nn.LeakyReLU(0.2, inplace=True),\n #nn.Dropout2d(0.5),\n \n #3\n # state size. (ngf*4) x 8 x 8\n nn.ConvTranspose2d( ngf * 8, ngf * 4, 4, 2, 1, bias=False),\n nn.LeakyReLU(0.2, inplace=True),\n #nn.Dropout2d(0.5),\n \n # G(z)\n nn.ConvTranspose2d( ngf * 4, nc, 4, 2, 1, bias=False),\n nn.Tanh() # Not used because ASPAs \n )\n\n def forward(self, input):\n return self.main(input)\n\n \nclass Discriminator(nn.Module):\n def __init__(self, ngpu, nc=1, ndf=32):\n super(Discriminator, self).__init__()\n self.ngpu = ngpu\n self.nc = nc\n self.ndf = ndf\n self.main = nn.Sequential(\n # input is (nc) x 64 x 64\n nn.Conv2d(nc, ndf*4, 4, 2, 1, bias=False),\n nn.LeakyReLU(0.2, inplace=True),\n #nn.Dropout2d(0.5),\n \n # state size. (ndf) x 32 x 32\n nn.Conv2d(ndf*4, ndf * 8, 4, 2, 1, bias=False),\n nn.LeakyReLU(0.2, inplace=True),\n #nn.Dropout2d(0.5),\n \n # state size. (ndf*2) x 16 x 16\n nn.Conv2d(ndf * 8, ndf * 16, 4, 2, 1, bias=False),\n nn.LeakyReLU(0.2, inplace=True),\n #nn.Dropout2d(0.5),\n \n # state size. (ndf*4) x 8 x 8\n nn.Conv2d(ndf * 16, 1, 4, 2, 1, bias=False),\n\n nn.Sigmoid()\n )\n\n def forward(self, input):\n return self.main(input)\n\n\n" ]

[ [ "torch.nn.ConvTranspose2d", "torch.nn.Conv2d", "torch.nn.Sigmoid", "torch.nn.Tanh", "torch.nn.LeakyReLU" ] ]

rafalou38/mangafetch

[ "6bd313f9b9cfb2ea729e49d382a4085c9aaf094e" ]

[ "src/images.py" ]

[ "import PIL.Image\nimport numpy\nimport os\n\n\ndef tile(image_path):\n try:\n ratio = 1.4\n image = PIL.Image.open(image_path)\n image = numpy.array(image)\n height = image.shape[1] * ratio\n\n if image.shape[1] * 2 < image.shape[0]:\n # width = image.shape[0]\n images = []\n y = 0\n for i in range(0, int(image.shape[0]), int(height)):\n chunk = image[i : int(i + height)]\n p = (\n os.path.splitext(image_path)[0]\n + \" cut \"\n + str(y)\n + os.path.splitext(image_path)[1]\n )\n PIL.Image.fromarray(chunk).save(p)\n images.append(p)\n y += 1\n return images\n else:\n return [image_path]\n except:\n return [image_path]\n\n\n# tile(\"tmp\\\\images\\\\sweet-home\\\\0\\\\1.jpeg\")\n# for image in tile(\"tmp\\\\images\\\\one-piece\\\\680\\\\1.jpeg\"):\n# \t# image.show()\n# \t# input()\n# \tprint(image)\n" ]

[ [ "numpy.array" ] ]

caegomezji/FORDAT

[ "450dca5a9b0c059429421b773be3e7d54367fdcf" ]

[ "forecasting.py" ]

[ "# ARIMA example\nfrom statsmodels.tsa.arima.model import ARIMA\nimport numpy as np\nfrom statsmodels.tools.eval_measures import rmse\nimport pmdarima as pm\nfrom fbprophet import Prophet\nfrom time import time\nimport matplotlib.pyplot as plt\nimport pandas as pd\nimport math\n\ndef BIC(y_real, y_model):\n n = len(y_real)\n k = 2\n resid = y_real - y_model\n sse = sum(resid**2)\n BIC_value = k * math.log(n) - 2 * math.log(sse)\n return BIC_value\n\ndef AIC(y_real, y_modelo):\n resid = y_real - y_modelo\n print(resid)\n sse = sum(resid**2)\n k = 1 # parameters\n AIC_value = 2*k - 2*math.log(sse)\n return AIC_value\n\ndef make_forecast(data, model='prophet'):\n\n data = data.interpolate()\n test_months = 6\n train, test = data[0:-test_months], data[-test_months:]\n history = [x for x in train]\n predictions = list()\n future_months = 18\n test_time = len(test)\n\n if model == 'prophet':\n predictions = forecast_prophet(train, future_months)\n elif model == 'autoarima':\n predictions = forecast_autoarima(train, future_months)\n\n return test, predictions\n\ndef forecast_autoarima(data, future_months=12):\n\n history = [x for x in data]\n\n model = pm.auto_arima(history, start_p=0, d=1, start_q=0,\n max_p=2, max_d=2, max_q=2, start_P=0,\n D=1, start_Q=0, max_P=2, max_D=2,\n max_Q=2, m=12, seasonal=True,\n error_action='warn', trace=True,\n supress_warnings=True, stepwise=True,\n random_state=20, n_fits=10)\n\n predictions = model.predict(future_months)\n \n return pd.Series(predictions)\n\ndef forecast_prophet(data, future_months=12):\n\n data_model = data.reset_index(name='FOBDOL')\n\n data_model.columns = ['ds', 'y' ] # prophet model just understando these names\n #print(data_model.shape)\n # HERE YOU SHOULD PUT YOUR MODEL\n print('start model')\n model = Prophet(interval_width=0.95, seasonality_mode='multiplicative')\n\n print('model defined')\n model.fit(data_model)\n print('model fitted')\n # future_months = 12 # this variable is a slider in the app\n future = model.make_future_dataframe(periods=future_months, freq='MS') # predict on months\n forecast = model.predict(future)\n predictions = forecast.yhat\n print('predicted')\n # in case you want to see its output\n # print(forecast.head(2))\n # print(predictions)\n return predictions[-future_months:].reset_index()['yhat']\n\ndef forcast_arima(data):\n # data[Sector ] == X\n data = data.interpolate()\n size = int(len(data) * 0.80)\n train, test = data[0:size], data[size:len(data)]\n history = [x for x in train]\n predictions = list()\n future_months = 12\n test_time = len(test)\n for t in range(test_time + future_months ):\n model = ARIMA(history, order=(5, 1, 0))\n model_fit = model.fit()\n output = model_fit.forecast()\n yhat = output[0]\n predictions.append(yhat)\n if t < test_time:\n obs = test[t]\n history.append(obs)\n if t >= test_time:\n history.append(yhat)\n\n # evaluate forecasts\n # error = np.sqrt(rmse(test, predictions))\n #print('Test RMSE: %.3f' % error)\n # plot forecasts against actual outcomes\n # plt.plot(np.array(test))\n # plt.plot(predictions, color='red')\n # plt.show()\n\n return test, predictions " ]

[ [ "pandas.Series" ] ]

guglielmocola/RetweetCascade

[ "f96319d0107473715104acceb2ff0925d35dd9e3" ]

[ "retweetcascade/rt_cascade_friendships.py" ]

[ "import pandas as pd\nfrom retweetcascade.utility_functions import __convert_to_pandas_list_tw, __explode_dict\n\n\ndef rt_cascade_friendships(retweets, followers, friends, **kwargs):\n \"\"\"Estimate the retweet cascade based on friendship among retweeters.\n A retweeter X is linked to the root R (original tweet's author) if he/she is a follower\n of R, otherwise it is linked to the last friend who retweeted before X. If X is not\n a follower of R and there are no friends who retweeted before X, then it is not possible\n to automatically link X to another retweeter, and X is disconnected from the cascade graph.\n\n :param retweets: list of retweets, each retweet being a tweet object.\n :param followers: list of followers of the root (id_str values).\n :param friends: dictionary describing the friends of retweeters (only the friends of\n retweeters who are not followers of the root are useful); each key is the id_str\n of a retweeter and points to the list of friends (id_str values).\n\n :keyword verbose: Verbose mode (default False)\n :keyword qt: Weight assigned to quotes (default 1.0)\n :keyword re: Weight assigned to replies (default 1.0)\n :keyword rt: Weight assigned to retweets (default 1.0)\n\n :return: Returns a pandas DataFrame with columns source and target, where each\n row describes an edge of the retweet cascade graph. Disconnected nodes are included with a\n target equal to NaN.\n \"\"\"\n\n # Set keyword arguments, start from default values\n verbose = False\n if 'verbose' in kwargs:\n verbose = kwargs['verbose']\n\n # Find the root from a retweet.\n root_id = retweets[0]['retweeted_status']['user']['id_str']\n\n # DataFrame with RETWEETS (in case of multiple retweets from the same subject, keep the oldest)\n df_rt = __convert_to_pandas_list_tw(retweets, ['created_at', 'user.id_str'])\n df_rt = df_rt.sort_values(by=['created_at'], ascending=False)\n df_rt = df_rt.groupby(df_rt['user.id_str']).last().reset_index() # last is the oldest\n\n # List of retweeters who also are followers (\"direct retweeters\")\n direct_rt_list = []\n # List of non-follower retweeters (will be useful later to find disconnected nodes)\n nf_rt_list = []\n for rt in retweets:\n rt_user = rt['user']['id_str']\n if rt_user in followers:\n direct_rt_list.append(rt_user)\n else:\n nf_rt_list.append(rt_user)\n # Remove duplicates\n direct_rt_list = list(set(direct_rt_list))\n\n # Create DataFrame for these users, then add it to the main one.\n df_direct = pd.DataFrame(direct_rt_list, columns=['source'])\n df_direct['target'] = root_id\n\n # Create rt DataFrame with just non-follower retweeters.\n df_nf_rt = df_rt[~df_rt['user.id_str'].isin(direct_rt_list)].reset_index(drop=True)\n\n # Create DataFrame for friendships, with <user.id, friend.id> info\n df_friends = pd.DataFrame(__explode_dict(friends)).T\n df_friends.columns = ['follower_id_str', 'friend_id_str']\n\n # First merge links non-follower retweeters with their friends\n df_merge1 = df_nf_rt.merge(df_friends, left_on='user.id_str', right_on='follower_id_str')\n\n # Second merge adds retweet information for friends (this time the merge needs to be with\n # the entire retweets DataFrame)\n df_merge2 = df_merge1.merge(df_rt, left_on='friend_id_str', right_on='user.id_str', suffixes=('', '_y'))\n\n # Remove rows where 'created_at_y' > 'created_at'\n df_merge2['delta'] = (df_merge2['created_at'] - df_merge2['created_at_y']).dt.total_seconds()\n df_merge2 = df_merge2[df_merge2['delta'] > 0]\n\n df_final = df_merge2[['user.id_str', 'created_at', 'friend_id_str', 'created_at_y', 'delta']]\n df_final = df_final.sort_values(by=['delta'], ascending=False)\n df_final = df_final.groupby(df_final['user.id_str']).last().reset_index() # last is the oldest\n\n # Prepare cascade DataFrame based on friendship, then cat it with direct followers\n cascade_df = pd.DataFrame()\n cascade_df['source'] = df_final['user.id_str']\n cascade_df['target'] = df_final['friend_id_str']\n\n # Save list of \"friend-based\" non follower retweeters for later.\n fb_rt_list = cascade_df['source'].tolist()\n\n # Cat with direct retweeters (followers of root)\n cascade_df = pd.concat([cascade_df, df_direct], ignore_index=True)\n\n # Finally, find disconnected nodes, and add a row with NaN target for them.\n disconnected_nodes = set(nf_rt_list) - set(fb_rt_list)\n\n # print('dis:', len(disconnected_nodes), 'nf:', len(set(nf_rt_list)), 'fb-estimated', len(set(fb_rt_list)))\n\n # fw_in_int = set(fb_rt_list) - set(direct_rt_list)\n # print(len(fw_in_int))\n\n # Add disconnected nodes with 'NaN' target\n disconnected_df = pd.DataFrame(\n {'source': list(disconnected_nodes),\n 'target': [float(\"NaN\")] * len(disconnected_nodes),\n })\n\n # Find final edges df, including disconnected nodes\n cascade_df = pd.concat([cascade_df, disconnected_df], ignore_index=True)\n\n # Remove the root from source, if present\n cascade_df.drop(cascade_df.loc[cascade_df['source'] == root_id].index, inplace=True)\n cascade_df.reset_index(inplace=True, drop=True)\n\n return cascade_df\n" ]

[ [ "pandas.concat", "pandas.DataFrame" ] ]

joshliu11/DSGN

[ "ac693e748ff3a7372b1292c2b7b3796854072030" ]

[ "dsgn/utils/torch_utils.py" ]

[ "import numpy as np\n\nimport torch\n\ndef project_image_to_rect(uv_depth, P):\n # uv_depth (3, N)\n\n c_u = P[0,2]\n c_v = P[1,2]\n f_u = P[0,0]\n f_v = P[1,1]\n b_x = P[0,3]/(-f_u) # relative \n b_y = P[1,3]/(-f_v)\n\n # use camera coordinate\n n = uv_depth.shape[1]\n x = ((uv_depth[0]-c_u)*uv_depth[2])/f_u + b_x\n y = ((uv_depth[1]-c_v)*uv_depth[2])/f_v + b_y\n return torch.stack([x, y, uv_depth[2]], dim=0)\n\ndef project_disp_to_depth_new(points_cam, Proj):\n xs, ys, disp = points_cam[0:1], points_cam[1:2], points_cam[2:3]\n _, h, w, d = disp.shape\n\n baseline = 0.54\n mask = disp > 0\n depth = Proj[0,0] * baseline / (disp + 1. - mask.float())\n points = torch.cat([xs, ys, depth], dim=0)\n points = points.reshape((3, -1))\n\n # camera coordinate\n cloud = project_image_to_rect(points, Proj)\n cloud = cloud.reshape(3, h, w, d)\n return cloud\n\ndef project_rect_to_image(pts_3d_rect, P):\n n = pts_3d_rect.shape[0]\n ones = torch.ones((n,1))\n if pts_3d_rect.is_cuda:\n ones = ones.cuda()\n pts_3d_rect = torch.cat([pts_3d_rect, ones], dim=1)\n pts_2d = torch.mm(pts_3d_rect, torch.transpose(P, 0, 1)) # nx3\n pts_2d[:,0] /= pts_2d[:,2]\n pts_2d[:,1] /= pts_2d[:,2]\n return pts_2d[:,0:2]\n\n# def compute_locations(h, w, stride, device):\n# shifts_x = torch.arange(\n# 0, w * stride, step=stride,\n# dtype=torch.float32, device=device\n# )\n# shifts_y = torch.arange(\n# 0, h * stride, step=stride,\n# dtype=torch.float32, device=device\n# )\n# shift_y, shift_x = torch.meshgrid(shifts_y, shifts_x)\n# shift_x = shift_x.reshape(-1)\n# shift_y = shift_y.reshape(-1)\n# locations = torch.stack((shift_x, shift_y), dim=1) + stride // 2\n# return locations\n\n# def compute_locations_3d(h, w, stride, device):\n# shifts_x = torch.arange(\n# 0, w * stride, step=stride,\n# dtype=torch.float32, device=device\n# )\n# shifts_y = torch.arange(\n# 0, h * stride, step=stride,\n# dtype=torch.float32, device=device\n# )\n# shift_y, shift_x = torch.meshgrid(shifts_y, shifts_x)\n# shift_x = shift_x.reshape(-1)\n# shift_y = shift_y.reshape(-1)\n# locations = torch.stack((shift_x, shift_y), dim=1) + stride // 2\n# return locations\n\ndef compute_locations_bev(Z_MIN, Z_MAX, VOXEL_Z_SIZE, X_MIN, X_MAX, VOXEL_X_SIZE, device):\n shifts_z = torch.arange(Z_MIN, Z_MAX - np.sign(VOXEL_Z_SIZE) * 1e-10, step=VOXEL_Z_SIZE, \n dtype=torch.float32).to(device) + VOXEL_Z_SIZE / 2.\n shifts_x = torch.arange(X_MIN, X_MAX - np.sign(VOXEL_X_SIZE) * 1e-10, step=VOXEL_X_SIZE,\n dtype=torch.float32).to(device) + VOXEL_X_SIZE / 2.\n shifts_z, shifts_x = torch.meshgrid(shifts_z, shifts_x)\n locations_bev = torch.stack([shifts_x, shifts_z], dim=-1)\n locations_bev = locations_bev.reshape(-1, 2)\n return locations_bev\n\ndef compute_centerness_targets(reg_targets):\n left_right = reg_targets[:, [0, 2]]\n top_bottom = reg_targets[:, [1, 3]]\n centerness = (left_right.min(dim=-1)[0] / left_right.max(dim=-1)[0]) * \\\n (top_bottom.min(dim=-1)[0] / top_bottom.max(dim=-1)[0])\n return torch.sqrt(centerness)\n\n# def compute_corners_R(dimensions, rot):\n# num_boxes = dimensions.shape[0]\n# h, w, l = torch.split( dimensions.view(num_boxes, 1, 3), [1, 1, 1], dim=2)\n# # zeros = torch.zeros((num_boxes, 1, 1), dtype=torch.float32).cuda()\n# corners = torch.cat([torch.cat([l/2, l/2, -l/2, -l/2, l/2, l/2, -l/2, -l/2], dim=2),\n# torch.cat([h/2, h/2, h/2, h/2, -h/2, -h/2, -h/2, -h/2], dim=2),\n# torch.cat([w/2, -w/2, -w/2, w/2, w/2, -w/2, -w/2, w/2], dim=2)], dim=1)\n# corners = torch.matmul(rot, corners)\n# return corners\n\n# def angle_to_bevrotation(sin, cos):\n# zeros = torch.zeros_like(sin)\n# rot_1 = torch.stack([cos, zeros, -sin], dim=1)\n# rot_2 = torch.stack([zeros, zeros+1., zeros], dim=1)\n# rot_3 = torch.stack([sin, zeros, cos], dim=1)\n# rot = torch.stack([rot_1, rot_2, rot_3], dim=1)\n# return rot\n\ndef convert_to_viewpoint_torch(ry, z, x):\n return ry + torch.atan2(z, x) - np.pi / 2\n\ndef convert_to_ry_torch(alpha, z, x):\n return alpha - torch.atan2(z, x) + np.pi / 2\n" ]

[ [ "torch.transpose", "torch.ones", "torch.cat", "torch.sqrt", "numpy.sign", "torch.stack", "torch.meshgrid", "torch.atan2" ] ]

meyer-lab/type-I-ckine-model

[ "bc0451610655633483a98ab450d20ef631479d2b" ]

[ "ckine/figures/figureC12.py" ]

[ "import os\nimport matplotlib.lines as mlines\nimport pandas as pds\nimport numpy as np\nfrom .figureCommon import subplotLabel, getSetup\nfrom ..flow import importF\nfrom ..PCA import sampleT\nfrom ..flow import gating, count_data\n\nfrom ..FCimports import compMatrix, applyMatrix\n\npath_here = os.path.dirname(os.path.dirname(__file__))\n\n\ndef makeFigure():\n \"\"\"Get a list of the axis objects and create a figure\"\"\"\n # Get list of axis objects\n ax, f = getSetup((10, 10), (4, 4))\n\n subplotLabel(ax)\n\n StatMV()\n\n # global_legend(ax[7])\n\n return f\n\n\ndef global_legend(ax):\n \"\"\" Create legend for Inverse and Standard Gini \"\"\"\n blue = mlines.Line2D([], [], color='navy', marker='o', linestyle='None', markersize=6, label='Gini Coeff')\n orange = mlines.Line2D([], [], color='darkorange', marker='o', linestyle='None', markersize=6, label='Inverse Gini Coeff')\n ax.legend(handles=[orange, blue], bbox_to_anchor=(0, 1), loc=\"upper left\")\n\n\ndef StatMV():\n \"\"\"\n Calculate mean and variance of a sample in a pandas dataframe, and plot.\n \"\"\"\n\n dataFiles = [\"/data/flow/2019-03-19 IL-2 and IL-15 treated pSTAT5 assay - Lymphocyte gated - Treg plate.zip\",\n \"/data/flow/2019-03-27 IL-2 and IL-15 treated pSTAT5 assay - Lymphocyte gated - Treg plate.zip\",\n \"/data/flow/2019-04-18 IL-2 and IL-15 treated pSTAT5 assay - Lymphocyte gated - Treg plate - NEW PBMC LOT/\",\n \"/data/flow/2019-03-15 IL-2 and IL-15 treated pSTAT5 assay - Lymphocyte gated - NK plate.zip\",\n \"/data/flow/2019-03-27 IL-2 and IL-15 treated pSTAT5 assay - Lymphocyte gated - NK plate.zip\",\n \"/data/flow/2019-04-18 IL-2 and IL-15 treated pSTAT5 assay - Lymphocyte gated - NK plate - NEW PBMC LOT.zip\"]\n dataFiles = [\"/home/brianoj/Tplate15\", \"/home/brianoj/Tplate27\", \"/home/brianoj/Tplate418\", \"/home/brianoj/Nkplate15\", \"/home/brianoj/Nkplate27\", \"/home/brianoj/Nkplate418\"]\n dates = [\"3/15/2019\", \"3/27/2019\", \"4/18/2019\", \"3/15/2019\", \"3/27/2019\", \"4/18/2019\"]\n rows = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']\n cellTypesT = ['treg', 'nonTreg']\n TitlesT = [\"Treg\", \"Thelper\"]\n masterMVdf = pds.DataFrame(columns={\"Date\", \"Time\", \"Cell\", \"Ligand\", \"Dose\", \"Mean\", \"Bin\", \"NumCells\"})\n MVdf = pds.DataFrame(columns={\"Date\", \"Time\", \"Cell\", \"Ligand\", \"Dose\", \"Mean\", \"Bin\", \"NumCells\"})\n alldata = []\n dosemat = np.array([[84, 28, 9.333333, 3.111, 1.037037, 0.345679, 0.115226, 0.038409, 0.012803, 0.004268, 0.001423, 0.000474]])\n repList = [0, 0, 0, 0, 0, 0]\n\n numBins = 4\n\n T_matrix = compMatrix(\"2019-11-08\", \"1\", \"A\") # Create matrix 1\n\n for i, filename in enumerate(dataFiles):\n if i < 3:\n Tcells = True\n else:\n Tcells = False\n\n if Tcells:\n statcol = \"RL1-H\"\n IL2RaCol = \"VL1-H\"\n for k, cell_type in enumerate(cellTypesT):\n for j, row in enumerate(rows):\n print(filename)\n sample, _ = importF(filename, row)\n if cell_type:\n for jj, subSample in enumerate(sample):\n sample[jj] = applyMatrix(subSample, T_matrix)\n gates = gating(cell_type, dates[i], True, repList[i])\n _, alldata = count_data(sample, gates, Tcells, True)\n else:\n for jj, samplejj in enumerate(sample):\n _, pstat, _ = sampleT(samplejj)\n alldata.append(pstat)\n\n for ii, _ in enumerate(sample): # get pstat data and put it into list form\n dat_array = alldata[ii]\n stat_array = dat_array[[statcol]]\n stat_array = stat_array.to_numpy()\n stat_array = stat_array.clip(min=1) # remove small percentage of negative pstat values\n IL2Ra_array = dat_array[[IL2RaCol]]\n IL2Ra_array = IL2Ra_array.to_numpy()\n IL2Ra_array = IL2Ra_array.clip(min=1)\n IL2Ra_array = IL2Ra_array / 1.5\n while np.amax(stat_array) > 100000:\n IL2Ra_array = np.reshape(IL2Ra_array[stat_array != np.amax(stat_array)], (-1, 1)) # Remove random exploding value\n stat_array = np.reshape(stat_array[stat_array != np.amax(stat_array)], (-1, 1)) # Remove random exploding value\n bins = np.logspace(np.log10(np.percentile(IL2Ra_array, 5)), np.log10(np.percentile(IL2Ra_array, 95)), num=numBins)\n\n for kk in range(0, bins.size - 1):\n binDat = stat_array[(IL2Ra_array > bins[kk]) & (IL2Ra_array < bins[kk + 1])]\n if stat_array.size == 0:\n MVdf = MVdf.append(pds.DataFrame.from_dict({\"Date\": dates[i], \"Time\": timeFunc(row), \"Cell\": TitlesT[k], \"Ligand\": cytFunc(row), \"Dose\": dosemat[0, ii], \"Mean\": [0],\n \"Bin\": [kk], \"NumCells\": 0, \"Bivalent\": [0]}))\n else:\n MVdf = MVdf.append(pds.DataFrame.from_dict({\"Date\": dates[i], \"Time\": timeFunc(row), \"Cell\": TitlesT[k], \"Ligand\": cytFunc(\n row), \"Dose\": dosemat[0, ii], \"Mean\": np.mean(binDat), \"Bin\": [kk + 1], \"NumCells\": [binDat.size], \"Bivalent\": [0]}))\n\n if j == 3 or j == 7:\n MVdf['Mean'] = MVdf['Mean'] - MVdf.loc[(MVdf.Dose <= 0.001423)].Mean.mean()\n masterMVdf = masterMVdf.append(MVdf)\n MVdf = pds.DataFrame(columns={\"Date\", \"Time\", \"Ligand\", \"Dose\", \"Mean\", \"Bin\", \"NumCells\", \"Bivalent\"})\n\n dataFiles = [\"/home/brianoj/Muteins 060-062 T/2019-04-19 IL2-060 IL2-062 Treg plate\",\n \"/home/brianoj/Muteins 088-097 T/2019-04-19 IL2-088 IL2-097 Treg plate\",\n \"/home/brianoj/Muteins 060-088 T/2019-05-02 IL2-060 IL2-088 Treg plate\",\n \"/home/brianoj/Muteins 062-097 T/2019-05-02 IL2-062 IL2-097 Treg plate\",\n \"/home/brianoj/Muteins 060-062 Nk/2019-04-19 IL2-060 IL2-062 NK plate\",\n \"/home/brianoj/Muteins 088-097 Nk/2019-04-19 IL2-088 IL2-097 NK plate\",\n \"/home/brianoj/Muteins 060-088 Nk/2019-05-02 IL2-060 IL2-088 NK plate\",\n \"/home/brianoj/Muteins 062-097 Nk/2019-05-02 IL2-062 IL2-097 NK plate\"]\n dates = [\"4/19/2019\", \"4/19/2019\", \"5/2/2019\", \"5/2/2019\", \"4/19/2019\", \"4/19/2019\", \"5/2/2019\", \"5/2/2019\"]\n repList = [0, 1, 0, 1, 0, 1, 0, 1]\n\n print(\"Starting Muteins\")\n\n for i, filename in enumerate(dataFiles):\n if i < 4:\n Tcells = True\n else:\n Tcells = False\n if Tcells:\n statcol = \"RL1-H\"\n for k, cell_type in enumerate(cellTypesT):\n for j, row in enumerate(rows):\n print(filename)\n sample, _ = importF(filename, row)\n if cell_type:\n for jj, subSample in enumerate(sample):\n sample[jj] = applyMatrix(subSample, T_matrix)\n gates = gating(cell_type, dates[i], True, repList[i])\n _, alldata = count_data(sample, gates, Tcells, True)\n else:\n for jj, samplejj in enumerate(sample):\n _, pstat, _ = sampleT(samplejj)\n alldata.append(pstat)\n\n for ii, _ in enumerate(sample): # get pstat data and put it into list form\n dat_array = alldata[ii]\n stat_array = dat_array[[statcol]]\n stat_array = stat_array.to_numpy()\n stat_array = stat_array.clip(min=1) # remove small percentage of negative pstat values\n IL2Ra_array = dat_array[[IL2RaCol]]\n IL2Ra_array = IL2Ra_array.to_numpy()\n IL2Ra_array = IL2Ra_array.clip(min=1)\n IL2Ra_array = IL2Ra_array / 1.5\n while np.amax(stat_array) > 100000:\n IL2Ra_array = np.reshape(IL2Ra_array[stat_array != np.amax(stat_array)], (-1, 1)) # Remove random exploding value\n stat_array = np.reshape(stat_array[stat_array != np.amax(stat_array)], (-1, 1)) # Remove random exploding value\n bins = np.logspace(np.log10(np.percentile(IL2Ra_array, 5)), np.log10(np.percentile(IL2Ra_array, 95)), num=numBins)\n timelig = mutFunc(row, filename)\n for kk in range(0, bins.size - 1):\n binDat = stat_array[(IL2Ra_array > bins[kk]) & (IL2Ra_array < bins[kk + 1])]\n if stat_array.size == 0:\n MVdf = MVdf.append(pds.DataFrame.from_dict({\"Date\": dates[i], \"Time\": timelig[0], \"Cell\": TitlesT[k], \"Ligand\": timelig[1], \"Dose\": dosemat[0, ii], \"Mean\": [0],\n \"Bin\": [kk], \"NumCells\": 0, \"Bivalent\": timelig[2]}))\n else:\n MVdf = MVdf.append(pds.DataFrame.from_dict({\"Date\": dates[i], \"Time\": timelig[0], \"Cell\": TitlesT[k], \"Ligand\": timelig[1],\n \"Dose\": dosemat[0, ii], \"Mean\": np.mean(binDat), \"Bin\": [kk + 1], \"NumCells\": [binDat.size], \"Bivalent\": timelig[2]}))\n if j == 3 or j == 7:\n MVdf['Mean'] = MVdf['Mean'] - MVdf.loc[(MVdf.Dose <= 0.001423)].Mean.mean()\n masterMVdf = masterMVdf.append(MVdf)\n MVdf = pds.DataFrame(columns={\"Date\", \"Time\", \"Ligand\", \"Dose\", \"Mean\", \"Bin\", \"NumCells\", \"Bivalent\"})\n\n masterMVdf.Mean = masterMVdf.Mean.clip(lower=0)\n masterMVdf = masterMVdf.loc[masterMVdf.Ligand != \"H16L N-term\"]\n masterMVdf.to_csv(\"WTDimericMutSingleCellDataBin.csv\", index=False)\n\n return MVdf\n\n\ndef timeFunc(letter):\n if letter == \"A\" or letter == \"E\":\n return 4.0\n elif letter == \"B\" or letter == \"F\":\n return 2.0\n elif letter == \"C\" or letter == \"G\":\n return 1.0\n elif letter == \"D\" or letter == \"H\":\n return 0.5\n\n\ndef cytFunc(letter):\n if letter == \"A\" or letter == \"B\" or letter == \"C\" or letter == \"D\":\n return \"IL2\"\n elif letter == \"E\" or letter == \"F\" or letter == \"G\" or letter == \"H\":\n return \"IL15\"\n\n\ndef mutFunc(letter, datafile):\n if datafile == \"/home/brianoj/Muteins 060-062 T/2019-04-19 IL2-060 IL2-062 Treg plate\" or datafile == \"/home/brianoj/Muteins 060-062 Nk/2019-04-19 IL2-060 IL2-062 NK plate\":\n if letter == \"A\":\n return [4.0, \"WT N-term\", 1]\n elif letter == \"B\":\n return [4.0, \"WT N-term\", 1]\n elif letter == \"C\":\n return [4.0, \"WT N-term\", 1]\n elif letter == \"D\":\n return [0.5, \"WT N-term\", 1]\n elif letter == \"E\":\n return [4.0, \"H16N N-term\", 1]\n elif letter == \"F\":\n return [2.0, \"H16N N-term\", 1]\n elif letter == \"G\":\n return [1.0, \"H16N N-term\", 1]\n elif letter == \"H\":\n return [2.0, \"WT N-term\", 1]\n\n elif datafile == \"/home/brianoj/Muteins 088-097 T/2019-04-19 IL2-088 IL2-097 Treg plate\" or datafile == \"/home/brianoj/Muteins 088-097 Nk/2019-04-19 IL2-088 IL2-097 NK plate\":\n if letter == \"A\":\n return [4.0, \"R38Q N-term\", 1]\n elif letter == \"B\":\n return [2.0, \"R38Q N-term\", 1]\n elif letter == \"C\":\n return [1.0, \"R38Q N-term\", 1]\n elif letter == \"D\":\n return [1.0, \"WT N-term\", 1]\n elif letter == \"E\":\n return [4.0, \"R38Q/H16N\", 1]\n elif letter == \"F\":\n return [2.0, \"R38Q/H16N\", 1]\n elif letter == \"G\":\n return [1.0, \"R38Q/H16N\", 1]\n elif letter == \"H\":\n return [0.5, \"R38Q/H16N\", 1]\n\n elif datafile == \"/home/brianoj/Muteins 060-088 T/2019-05-02 IL2-060 IL2-088 Treg plate\" or datafile == \"/home/brianoj/Muteins 060-088 Nk/2019-05-02 IL2-060 IL2-088 NK plate\":\n if letter == \"A\":\n return [4.0, \"WT N-term\", 1]\n elif letter == \"B\":\n return [4.0, \"WT N-term\", 1]\n elif letter == \"C\":\n return [4.0, \"WT N-term\", 1]\n elif letter == \"D\":\n return [0.5, \"WT N-term\", 1]\n elif letter == \"E\":\n return [4.0, \"R38Q N-term\", 1]\n elif letter == \"F\":\n return [2.0, \"R38Q N-term\", 1]\n elif letter == \"G\":\n return [1.0, \"R38Q N-term\", 1]\n elif letter == \"H\":\n return [2.0, \"R38Q N-term\", 1]\n\n elif datafile == \"/home/brianoj/Muteins 062-097 T/2019-05-02 IL2-062 IL2-097 Treg plate\" or datafile == \"/home/brianoj/Muteins 062-097 Nk/2019-05-02 IL2-062 IL2-097 NK plate\":\n if letter == \"A\":\n return [4.0, \"H16N N-term\", 1]\n elif letter == \"B\":\n return [2.0, \"H16N N-term\", 1]\n elif letter == \"C\":\n return [1.0, \"H16N N-term\", 1]\n elif letter == \"D\":\n return [1.0, \"H16N N-term\", 1]\n elif letter == \"E\":\n return [4.0, \"R38Q/H16N\", 1]\n elif letter == \"F\":\n return [2.0, \"R38Q/H16N\", 1]\n elif letter == \"G\":\n return [1.0, \"R38Q/H16N\", 1]\n elif letter == \"H\":\n return [0.5, \"R38Q/H16N\", 1]\n" ]

[ [ "numpy.amax", "matplotlib.lines.Line2D", "numpy.percentile", "pandas.DataFrame", "numpy.mean", "pandas.DataFrame.from_dict", "numpy.array" ] ]

ravising-h/Grad-CAM.pytorch

[ "e0a1ae3870ea189f9b4cd8782eb77bfb5293c31b" ]

[ "detection/demo_retinanet.py" ]

[ "# -*- coding: utf-8 -*-\n\"\"\"\n @File : demo_retinanet.py\n @Time : 2020/5/16 下午9:59\n @Author : yizuotian\n @Description :\n\"\"\"\n\nimport argparse\nimport multiprocessing as mp\nimport os\n\nfrom tqdm import tqdm\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.axes_grid1 import ImageGrid\nimport cv2\nimport detectron2.data.transforms as T\nimport numpy as np\nimport torch\nfrom detectron2.checkpoint import DetectionCheckpointer\nfrom detectron2.config import get_cfg\nfrom detectron2.data import MetadataCatalog\nfrom detectron2.data.detection_utils import read_image\nfrom detectron2.modeling import build_model\nfrom detectron2.utils.logger import setup_logger\nfrom skimage import io\n\nfrom grad_cam_retinanet import GradCAM, GradCamPlusPlus\n\n# constants\nWINDOW_NAME = \"COCO detections\"\n\n\ndef setup_cfg(args):\n # load config from file and command-line arguments\n cfg = get_cfg()\n cfg.merge_from_file(args.config_file)\n cfg.merge_from_list(args.opts)\n # Set score_threshold for builtin models\n cfg.MODEL.RETINANET.SCORE_THRESH_TEST = 0.25\n cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = args.confidence_threshold\n cfg.MODEL.PANOPTIC_FPN.COMBINE.INSTANCES_CONFIDENCE_THRESH = args.confidence_threshold\n cfg.freeze()\n return cfg\n\n\ndef norm_image(image):\n \"\"\"\n 标准化图像\n :param image: [H,W,C]\n :return:\n \"\"\"\n image = image.copy()\n image -= np.max(np.min(image), 0)\n image /= np.max(image)\n image *= 255.\n return np.uint8(image)\n\n\ndef gen_cam(image, mask):\n \"\"\"\n 生成CAM图\n :param image: [H,W,C],原始图像\n :param mask: [H,W],范围0~1\n :return: tuple(cam,heatmap)\n \"\"\"\n # mask转为heatmap\n heatmap = cv2.applyColorMap(np.uint8(255 * mask), cv2.COLORMAP_JET)\n heatmap = np.float32(heatmap) / 255\n heatmap = heatmap[..., ::-1] # gbr to rgb\n\n # 合并heatmap到原始图像\n cam = heatmap + np.float32(image)\n return norm_image(cam), heatmap\n\n\ndef save_image(image_dicts, input_image_name, layer_name, network='retinanet', output_dir='./results'):\n prefix = os.path.splitext(input_image_name)[0]\n for key, image in image_dicts.items():\n if key == 'predict_box':\n io.imsave(os.path.join(output_dir,\n '{}-{}-{}.jpg'.format(prefix, network, key)),\n image)\n else:\n io.imsave(os.path.join(output_dir,\n '{}-{}-{}-{}.jpg'.format(prefix, network, layer_name, key)),\n (255 * image).astype(np.uint8) )\n\n\ndef get_parser():\n parser = argparse.ArgumentParser(description=\"Detectron2 demo for builtin models\")\n parser.add_argument(\n \"--config-file\",\n default=\"configs/quick_schedules/mask_rcnn_R_50_FPN_inference_acc_test.yaml\",\n metavar=\"FILE\",\n help=\"path to config file\",\n )\n parser.add_argument(\"--input\", help=\"A list of space separated input images\")\n parser.add_argument(\n \"--output\",\n help=\"A file or directory to save output visualizations. \"\n \"If not given, will show output in an OpenCV window.\",\n )\n\n parser.add_argument(\n \"--confidence-threshold\",\n type=float,\n default=0.2,\n help=\"Minimum score for instance predictions to be shown\",\n )\n parser.add_argument(\n \"--opts\",\n help=\"Modify config options using the command-line 'KEY VALUE' pairs\",\n default=[],\n nargs=argparse.REMAINDER,\n )\n parser.add_argument('--layer-name', type=str, default='head.cls_subnet.2',\n help='使用哪层特征去生成CAM')\n return parser\n\n\ndef main(args):\n from detectron2.data.datasets import register_coco_instances\n register_coco_instances(\"Dent_Detection_train\", {}, \"/content/drive/MyDrive/Damage/Dataset/coco_15k_balanced/annotations/instance_train2017.json\", \"/content/drive/MyDrive/Damage/Dataset/coco_15k_balanced/JPEGImages\")\n register_coco_instances(\"Dent_Detection_test\", {}, \"/content/drive/MyDrive/Damage/Dataset/coco_15k_balanced/annotations/instance_val2017.json\", \"/content/drive/MyDrive/Damage/Dataset/coco_15k_balanced/JPEGImages\")\n MetadataCatalog.get(\"Dent_Detection_test\").thing_classes = ['Dent']\n setup_logger(name=\"fvcore\")\n logger = setup_logger()\n logger.info(\"Arguments: \" + str(args))\n\n cfg = setup_cfg(args)\n print(cfg)\n \n model = build_model(cfg)\n\n checkpointer = DetectionCheckpointer(model)\n checkpointer.load(cfg.MODEL.WEIGHTS)\n\n\n path = os.path.expanduser(args.input)\n original_image = read_image(path, format=\"BGR\")\n height, width = original_image.shape[:2]\n transform_gen = T.ResizeShortestEdge(\n [cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST], cfg.INPUT.MAX_SIZE_TEST\n )\n image = transform_gen.get_transform(original_image).apply_image(original_image)\n image = torch.as_tensor(image.astype(\"float32\").transpose(2, 0, 1)).requires_grad_(True)\n\n inputs = {\"image\": image, \"height\": height, \"width\": width}\n\n # Grad-CAM\n img_grid = [0]*18\n for ly in tqdm(range(8), desc =\"LAYER BY LAYER\"):\n layer_name = f'head.cls_subnet.{ly}'\n grad_cam = GradCAM(model, layer_name)\n mask, box, class_id = grad_cam(inputs) # cam mask\n grad_cam.remove_handlers()\n\n #\n image_dict = {}\n img = original_image[..., ::-1]\n x1, y1, x2, y2 = box\n image_dict['predict_box'] = img[y1:y2, x1:x2]\n img_grid[0], img_grid[9] = image_dict['predict_box'] , image_dict['predict_box'] \n image_cam, image_dict['heatmap'] = gen_cam(img[y1:y2, x1:x2], mask[y1:y2, x1:x2])\n img_grid[ly+1] = (image_dict['heatmap']*255).astype(np.uint8)\n \n # Grad-CAM++\n grad_cam_plus_plus = GradCamPlusPlus(model, layer_name)\n mask_plus_plus = grad_cam_plus_plus(inputs) # cam mask\n\n _, image_dict['heatmap++'] = gen_cam(img[y1:y2, x1:x2], mask_plus_plus[y1:y2, x1:x2])\n img_grid[ly+9] = (image_dict['heatmap++']*255).astype(np.uint8)\n grad_cam_plus_plus.remove_handlers()\n\n # 获取类别名称\n meta = MetadataCatalog.get(\n cfg.DATASETS.TEST[0] if len(cfg.DATASETS.TEST) else \"__unused\"\n )\n label = meta.thing_classes[class_id]\n\n print(\"label:{}\".format(label))\n \n fig = plt.figure(figsize=(20., 6.))\n grid = ImageGrid(fig, 111, # similar to subplot(111)\n nrows_ncols=(2, 9), # creates 2x2 grid of axes\n axes_pad=0.1, # pad between axes in inch.\n )\n\n for ax, im_ in zip(grid, img_grid):\n # Iterating over the grid returns the Axes.\n ax.imshow(cv2.addWeighted(im_, 0.6, img_grid[0], 0.4, 0.2))\n \n plt.savefig(os.path.join(output_dir, f'{os.path.basename(path)}-grid.jpg'))\n # save_image(image_dict, os.path.basename(path), args.layer_name)\n\n\nif __name__ == \"__main__\":\n \"\"\"\n Usage:export KMP_DUPLICATE_LIB_OK=TRUE\n python detection/demo_retinanet.py --config-file detection/retinanet_R_50_FPN_3x.yaml \\\n --input ./examples/pic1.jpg \\\n --layer-name head.cls_subnet.7 \\\n --opts MODEL.WEIGHTS /Users/yizuotian/pretrained_model/model_final_4cafe0.pkl MODEL.DEVICE cpu\n \"\"\"\n mp.set_start_method(\"spawn\", force=True)\n arguments = get_parser().parse_args()\n main(arguments)\n" ]

[ [ "numpy.min", "numpy.uint8", "numpy.max", "numpy.float32", "matplotlib.pyplot.figure" ] ]

sayan2207/Class-Predictor

[ "191d98ca4d10d75fef24a4b6b78022c57679d4bc" ]

[ "predict_class_sklearn.py" ]

[ "import numpy as np\nimport random\nimport scipy.stats as ss\nimport matplotlib.pyplot as plt\nfrom matplotlib.colors import ListedColormap as lcm\nfrom sklearn.neighbors import KNeighborsClassifier as knc\nfrom time import strftime as stime\nimport os\n\ndef synthetic_plot(limits=(-5,5,-5,5), unit=0.1, no_of_points=20, no_of_classes=2, k=5):\n (predictors, outcomes) = generate_synth_data(no_of_points, no_of_classes)\n \n genuine_plot(predictors, outcomes, limits, unit, k)\n \ndef genuine_plot(predictors, outcomes, limits=(-5,5,-5,5), unit=0.1, k=5, home=False):\n (xx, yy, prediction_grid) = make_prediction_grid(predictors, outcomes, limits, unit, k)\n \n plot_prediction_grid(xx, yy, prediction_grid, predictors, outcomes);\n\n\ndef plot_prediction_grid (xx, yy, predicted_grid, predictors, outcomes):\n \"\"\" Plot KNN predictions for every point on the grid.\"\"\"\n \n types = len( set( outcomes ) )\n \n c_bg = np.zeros((types,3))\n c_ob = np.zeros((types,3))\n \n for i in range(types):\n c_bg_i = np.array([random.randint(100,255) / 255, random.randint(100,255) / 255, random.randint(100,255) / 255])\n c_ob_i = (c_bg_i*255 - 50)/255\n \n c_bg[i] = c_bg_i\n c_ob[i] = c_ob_i\n \n \n background_colormap = lcm(c_bg)\n observation_colormap = (c_ob)\n \n plt.figure( figsize =(10,10) )\n \n plt.pcolormesh(xx, yy, predicted_grid, cmap = background_colormap, alpha = 0.5)\n \n xs = np.array(predictors[:,0])\n ys = np.array(predictors[:,1])\n outcomes = np.array( outcomes )\n \n \n for i in range(types):\n to_plot = outcomes==i\n plt.scatter(xs[to_plot] , ys[to_plot] ,s = 50,color=observation_colormap[i] , label=\"Class \"+str(i+1))\n \n plt.xlabel('Variable 1'); plt.ylabel('Variable 2')\n \n x_labels = np.linspace( np.min(xx), np.max(xx), 5 )\n y_labels = np.linspace( np.min(yy), np.max(yy), 5 )\n \n plt.xticks(x_labels, rotation=\"vertical\")\n plt.yticks(y_labels)\n \n plt.xlim (np.min(xx), np.max(xx))\n plt.ylim (np.min(yy), np.max(yy))\n \n plt.legend(loc=\"lower right\")\n \n if not os.path.exists(\"Plots\"):\n os.makedirs(\"Plots\")\n \n filename = \"Plots\\plot_\" + stime(\"%d-%m-%Y_%H-%M-%S\") + \".pdf\"\n plt.savefig(filename)\n plt.show()\n\ndef make_prediction_grid(points, outcomes, limits, steps=1, k=5):\n (x_min, x_max, y_min, y_max) = limits\n xs = np.arange(x_min, x_max, steps)\n ys = np.arange(y_min, y_max, steps)\n \n \n knn = knc(n_neighbors=k)\n knn.fit(points,outcomes)\n \n (xx, yy) = np.meshgrid(xs, ys)\n \n prediction_grid = np.zeros(xx.shape, dtype=int)\n \n \n for i,x in enumerate(xs):\n for j,y in enumerate(ys):\n p = np.array([x,y])\n prediction_grid[j,i] = knn.predict([p])[0]\n \n return (xx, yy, prediction_grid)\n \n\ndef generate_synth_data(n=50,types=2):\n points = ss.norm(0 , 1).rvs((n,2))\n outcomes = np.repeat(0 , n)\n for i in range(1,types):\n points = np.concatenate( (points, ss.norm(i , 1).rvs((n,2)) ), axis=0 )\n outcomes = np.concatenate( (outcomes, np.repeat(i,n)) )\n return (points, outcomes)\n\n\n" ]

[ [ "matplotlib.pyplot.legend", "numpy.max", "numpy.arange", "sklearn.neighbors.KNeighborsClassifier", "numpy.repeat", "numpy.zeros", "matplotlib.pyplot.figure", "numpy.min", "matplotlib.pyplot.savefig", "matplotlib.colors.ListedColormap", "matplotlib.pyplot.pcolormesh", "numpy.meshgrid", "numpy.array", "matplotlib.pyplot.show", "matplotlib.pyplot.xticks", "matplotlib.pyplot.ylabel", "scipy.stats.norm", "matplotlib.pyplot.xlabel", "matplotlib.pyplot.yticks" ] ]

apigott/dra

[ "c2f24d9ef6d9d8cb78c5a058574cec8e132afd4f" ]

[ "dragg/reformat.py" ]

[ "import os\nimport sys\nimport json\nimport toml\nfrom datetime import datetime, timedelta\nimport numpy as np\nimport pandas as pd\nimport itertools as it\nimport random\n\nimport plotly.graph_objects as go\nimport plotly.express as px\nfrom plotly.subplots import make_subplots\nimport plotly.io as pio\nimport plotly\nfrom prettytable import PrettyTable\n\nfrom dragg.logger import Logger\n\nclass Reformat:\n def __init__(self):\n self.log = Logger(\"reformat\")\n\n self.data_dir = os.path.expanduser(os.environ.get('DATA_DIR','data'))\n self.outputs_dir = os.path.expanduser(os.environ.get('OUTPUT_DIR','outputs'))\n if not os.path.isdir(self.outputs_dir):\n self.log.logger.error(\"No outputs directory found.\")\n quit()\n self.config_file = os.path.join(self.data_dir, os.environ.get('CONFIG_FILE', 'config.toml'))\n self.config = self._import_config()\n\n self.add_date_ranges()\n self.add_mpc_params()\n self.date_folders = self.set_date_folders()\n self.mpc_folders = self.set_mpc_folders()\n self.files = self.set_files()\n\n self.fig_list = None\n self.save_path = os.path.join('outputs', 'images', datetime.now().strftime(\"%m%dT%H%M%S\"))\n\n def main(self):\n # put a list of plotting functions here\n self.sample_home = \"Crystal-RXXFA\"\n self.plots = [self.rl2baseline,\n self.plot_single_home]\n\n self.images = self.plot_all()\n\n def plot_all(self, save_images=False):\n figs = []\n for plot in self.plots:\n fig = make_subplots(specs=[[{\"secondary_y\": True}]])\n fig.update_layout(\n font=dict(\n size=65,\n )\n )\n fig.update_xaxes(\n title_standoff=80\n )\n fig.update_yaxes(\n title_standoff=60\n )\n fig = plot(fig)\n fig.show()\n figs += [fig]\n return figs\n\n def save_images(self):\n if not os.path.isdir(self.save_path):\n os.makedirs(self.save_path)\n for img in self.images:\n self.log.logger.info(f\"Saving images of outputs to timestamped folder at {self.save_path}.\")\n try:\n path = os.path.join(self.save_path, f\"{img.layout.title.text}.png\")\n pio.write_image(img, path, width=1024, height=768)\n except:\n self.log.logger.error(\"Could not save plotly image(s) to outputs directory.\")\n\n def add_date_ranges(self):\n start_dates = set([datetime.strptime(self.config['simulation']['start_datetime'], '%Y-%m-%d %H')])\n end_dates = set([datetime.strptime(self.config['simulation']['end_datetime'], '%Y-%m-%d %H')])\n temp = {\"start_datetime\": start_dates, \"end_datetime\": end_dates}\n self.date_ranges = temp\n\n def add_mpc_params(self):\n n_houses = self.config['community']['total_number_homes']\n mpc_horizon = self.config['home']['hems']['prediction_horizon']\n dt = self.config['home']['hems']['sub_subhourly_steps']\n solver = self.config['home']['hems']['solver']\n check_type = self.config['simulation']['check_type']\n agg_interval = self.config['agg']['subhourly_steps']\n temp = {\"n_houses\": set([n_houses]), \"mpc_prediction_horizons\": set([mpc_horizon]), \"mpc_hourly_steps\": set([dt]), \"check_type\": set([check_type]), \"agg_interval\": set([agg_interval]), \"solver\": set([solver])}\n # for key in temp:\n # if key in additional_params:\n # temp[key] |= set(additional_params[key])\n self.mpc_params = temp\n\n self.versions = set([self.config['simulation']['named_version']])\n\n def set_date_folders(self):\n temp = []\n # self.date_ranges['mpc_steps'] = set([self.config['home']['hems']['sub_subhourly_steps']])\n # self.date_ranges['rl_steps'] = set([self.config['agg']['subhourly_steps']])\n keys, values = zip(*self.date_ranges.items())\n permutations = [dict(zip(keys, v)) for v in it.product(*values)]\n permutations = sorted(permutations, key=lambda i: i['end_datetime'], reverse=True)\n\n for i in permutations:\n date_folder = os.path.join(self.outputs_dir, f\"{i['start_datetime'].strftime('%Y-%m-%dT%H')}_{i['end_datetime'].strftime('%Y-%m-%dT%H')}\")\n self.log.logger.info(f\"Looking for files in: {date_folder}.\")\n if os.path.isdir(date_folder):\n hours = i['end_datetime'] - i['start_datetime']\n hours = int(hours.total_seconds() / 3600)\n\n new_folder = {\"folder\": date_folder, \"hours\": hours, \"start_dt\": i['start_datetime']}\n temp.append(new_folder)\n\n if len(temp) == 0:\n self.log.logger.error(\"No files found for the date ranges specified.\")\n exit()\n\n return temp\n\n def set_mpc_folders(self):\n temp = []\n keys, values = zip(*self.mpc_params.items())\n permutations = [dict(zip(keys, v)) for v in it.product(*values)]\n for j in self.date_folders:\n for i in permutations:\n mpc_folder = os.path.join(j[\"folder\"], f\"{i['check_type']}-homes_{i['n_houses']}-horizon_{i['mpc_prediction_horizons']}-interval_{60 // i['agg_interval']}-{60 // i['mpc_hourly_steps'] // i['agg_interval']}-solver_{i['solver']}\")\n if os.path.isdir(mpc_folder):\n timesteps = j['hours'] * i['agg_interval']\n minutes = 60 // i['agg_interval']\n x_lims = [j['start_dt'] + timedelta(minutes=minutes*x) for x in range(timesteps)]\n\n set = {'path': mpc_folder, 'agg_dt': i['agg_interval'], 'ts': timesteps, 'x_lims': x_lims,}\n if not mpc_folder in temp:\n temp.append(set)\n for x in temp:\n print(x['path'])\n return temp\n\n def set_files(self):\n temp = []\n keys, values = zip(*self.mpc_params.items())\n permutations = [dict(zip(keys, v)) for v in it.product(*values)]\n\n color_families = [['rgb(204,236,230)','rgb(153,216,201)','rgb(102,194,164)','rgb(65,174,118)','rgb(35,139,69)','rgb(0,88,36)'],\n ['rgb(191,211,230)','rgb(158,188,218)','rgb(140,150,198)','rgb(140,107,177)','rgb(136,65,157)','rgb(110,1,107)'],\n ['rgb(217,217,217)','rgb(189,189,189)','rgb(150,150,150)','rgb(115,115,115)','rgb(82,82,82)','rgb(37,37,37)'],\n ['rgb(253,208,162)','rgb(253,174,107)','rgb(253,141,60)','rgb(241,105,19)','rgb(217,72,1)','rgb(140,45,4)'],]\n c = 0\n d = 0\n dash = [\"solid\", \"dash\", \"dot\", \"dashdot\"]\n for j in self.mpc_folders:\n path = j['path']\n for i in permutations:\n for k in self.versions:\n dir = os.path.join(path, f\"version-{k}\")\n for case_dir in os.listdir(dir):\n file = os.path.join(dir, case_dir, \"results.json\")\n if os.path.isfile(file):\n name = f\"{case_dir}, v = {k}\"\n set = {\"results\": file, \"name\": name, \"parent\": j, \"color\": color_families[c][d], \"dash\":dash[c]}\n temp.append(set)\n self.log.logger.info(f\"Adding baseline file at {file}\")\n d = (d + 1) % len(color_families[c])\n c = (c + 1) % len(color_families)\n\n return temp\n\n def get_type_list(self, type):\n type_list = set([])\n i = 0\n for file in self.files:\n with open(file[\"results\"]) as f:\n data = json.load(f)\n\n temp = set([])\n for name, house in data.items():\n try:\n if house[\"type\"] == type:\n temp.add(name)\n except:\n pass\n\n if i < 1:\n type_list = temp\n else:\n type_list = type_list.intersection(temp)\n\n self.log.logger.info(f\"{len(type_list)} homes found of type {type}: {type_list}\")\n return type_list\n\n def _import_config(self):\n if not os.path.exists(self.config_file):\n self.log.logger.error(f\"Configuration file does not exist: {self.config_file}\")\n sys.exit(1)\n\n with open(self.config_file, 'r') as f:\n data = toml.load(f)\n\n return data\n\n def plot_environmental_values(self, name, fig, summary, file, fname):\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=summary[\"OAT\"][0:file[\"parent\"][\"ts\"]], name=f\"OAT (C)\", visible='legendonly'))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=summary[\"GHI\"][0:file[\"parent\"][\"ts\"]], name=f\"GHI\", line={'color':'goldenrod', 'width':8}, visible='legendonly'))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=summary[\"TOU\"][0:file[\"parent\"][\"ts\"]], name=f\"TOU Price ($/kWh)\", line_shape='hv', visible='legendonly'), secondary_y=True)\n fig = self.plot_thermal_bounds(fig, file['parent']['x_lims'], name, fname)\n return fig\n\n def plot_thermal_bounds(self, fig, x_lims, name, fname):\n ah_file = os.path.join(self.outputs_dir, f\"all_homes-{self.config['community']['total_number_homes']}-config.json\")\n with open(ah_file) as f:\n data = json.load(f)\n\n for dict in data:\n if dict['name'] == name:\n data = dict\n\n fig.add_trace(go.Scatter(x=x_lims, y=data['hvac']['temp_in_min'] * np.ones(len(x_lims)), name=f\"Tin_min\", fill=None, showlegend=False, mode='lines', line_color='lightsteelblue'))\n fig.add_trace(go.Scatter(x=x_lims, y=data['hvac']['temp_in_max'] * np.ones(len(x_lims)), name=f\"Tin_bounds\", fill='tonexty' , mode='lines', line_color='lightsteelblue'))\n\n fig.add_trace(go.Scatter(x=x_lims, y=data['wh']['temp_wh_min'] * np.ones(len(x_lims)), name=f\"Twh_min\", fill=None, showlegend=False, mode='lines', line_color='pink'))\n fig.add_trace(go.Scatter(x=x_lims, y=data['wh']['temp_wh_max'] * np.ones(len(x_lims)), name=f\"Twh_bounds\", fill='tonexty' , mode='lines', line_color='pink'))\n return fig\n\n def plot_base_home(self, name, fig, data, summary, fname, file, plot_price=True):\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=data[\"temp_in_opt\"], name=f\"Tin - {fname}\", legendgroup='tin', line={'color':'blue', 'width':8, 'dash':file['dash']}))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=data[\"temp_wh_opt\"], showlegend=True, legendgroup='twh', name=f\"Twh - {fname}\", line={'color':'firebrick', 'width':8, 'dash':file['dash']}))\n\n fig.update_layout(legend=dict(\n yanchor=\"top\",\n y=0.99,\n xanchor=\"left\",\n x=0.03,\n font=dict(\n size=65),\n ),\n yaxis_title=\"Temperature (deg C)\"\n )\n\n return fig\n\n def plot_pv(self, name, fig, data, fname, file):\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=data[\"p_pv_opt\"], name=f\"Ppv (kW)\", line_color='orange', line_shape='hv', visible='legendonly'))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=data[\"u_pv_curt_opt\"], name=f\"U_pv_curt (kW) - {fname}\", line_shape='hv', visible='legendonly'))\n return fig\n\n def plot_battery(self, name, fig, data, fname, file):\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=data[\"e_batt_opt\"], name=f\"SOC (kW) - {fname}\", line_shape='hv', visible='legendonly'))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=data[\"p_batt_ch\"], name=f\"Pch (kW) - {fname}\", line_shape='hv', visible='legendonly'))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=data[\"p_batt_disch\"], name=f\"Pdis (kW) - {fname}\", line_shape='hv', visible='legendonly'))\n return fig\n\n def plot_single_home(self, fig):\n if self.sample_home is None:\n if type is None:\n type = \"base\"\n self.log.logger.warning(\"Specify a home type or name. Proceeding with home of type: \\\"base\\\".\")\n\n type_list = self._type_list(type)\n self.sample_home = random.sample(type_list,1)[0]\n self.log.logger.info(f\"Proceeding with home: {name}\")\n\n flag = False\n for file in self.files:\n with open(file[\"results\"]) as f:\n comm_data = json.load(f)\n\n try:\n data = comm_data[self.sample_home]\n except:\n self.log.logger.error(f\"No home with name: {self.sample_home}\")\n return\n\n type = data[\"type\"]\n summary = comm_data[\"Summary\"]\n\n if not flag:\n fig = self.plot_environmental_values(self.sample_home, fig, summary, file, file[\"name\"])\n flag = True\n\n fig.update_xaxes(title_text=\"Time of Day (hour)\")\n fig.update_layout(title_text=f\"{self.sample_home} - {type} type\")\n\n fig = self.plot_base_home(self.sample_home, fig, data, summary, file[\"name\"], file)\n\n if 'pv' in type:\n fig = self.plot_pv(self.sample_home, fig, data, file[\"name\"], file)\n\n if 'batt' in type:\n fig = self.plot_battery(self.sample_home, fig, data, file[\"name\"], file)\n\n return fig\n\n def plot_all_homes(self, fig=None):\n homes = [\"Crystal-RXXFA\",\"Myles-XQ5IA\",\"Lillie-NMHUH\",\"Robert-2D73X\",\"Serena-98EPE\",\"Gary-U95TS\",\"Bruno-PVRNB\",\"Dorothy-9XMNY\",\"Jason-INS3S\",\"Alvin-4BAYB\",]\n for self.sample_home in homes:\n fig = make_subplots(specs=[[{\"secondary_y\": True}]])\n fig.update_layout(\n font=dict(\n size = 12\n )\n )\n fig = self.plot_single_home(fig)\n\n return\n\n def plot_baseline(self, fig):\n for file in self.files:\n with open(file[\"results\"]) as f:\n data = json.load(f)\n\n ts = len(data['Summary']['p_grid_aggregate'])-1\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=data[\"Summary\"][\"p_grid_aggregate\"], name=f\"Agg Load - {file['name']}\", line_shape='hv', line={'color':file['color'], 'width':4, 'dash':'solid'}))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=np.cumsum(np.divide(data[\"Summary\"][\"p_grid_aggregate\"], file['parent']['agg_dt'])), name=f\"Cumulative Agg Load - {file['name']}\", line_shape='hv', visible='legendonly', line={'color':file['color'], 'width':4, 'dash':'dash'}))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=np.divide(np.cumsum(data[\"Summary\"][\"p_grid_aggregate\"]), np.arange(ts + 1) + 1), name=f\"Avg Cumulative Agg Load - {file['name']}\", line_shape='hv', visible='legendonly', line={'color':file['color'], 'width':4, 'dash':'dashdot'}))\n return fig\n\n def plot_typ_day(self, fig):\n rl_counter = 0\n tou_counter = 0\n dn_counter = 0\n for file in self.files:\n flag = True\n\n with open(file[\"results\"]) as f:\n data = json.load(f)\n\n name = file[\"name\"]\n\n ts = len(data['Summary']['p_grid_aggregate'])-1\n rl_setpoint = data['Summary']['p_grid_setpoint']\n if 'clipped' in file['name']:\n rl_setpoint = np.clip(rl_setpoint, 45, 60)\n loads = np.array(data[\"Summary\"][\"p_grid_aggregate\"])\n loads = loads[:len(loads) // (24*file['parent']['agg_dt']) * 24 * file['parent']['agg_dt']]\n if len(loads) > 24:\n daily_max_loads = np.repeat(np.amax(loads.reshape(-1, 24*file['parent']['agg_dt']), axis=1), 24*file['parent']['agg_dt'])\n daily_min_loads = np.repeat(np.amin(loads.reshape(-1, 24*file['parent']['agg_dt']), axis=1), 24*file['parent']['agg_dt'])\n daily_range_loads = np.subtract(daily_max_loads, daily_min_loads)\n daily_range_loads = [abs(loads[max(i-6, 0)] - loads[min(i+6, len(loads)-1)]) for i in range(len(loads))]\n daily_avg_loads = np.repeat(np.mean(loads.reshape(-1, 24*file['parent']['agg_dt']), axis=1), 24*file['parent']['agg_dt'])\n daily_std_loads = np.repeat(np.std(loads.reshape(-1, 24*file['parent']['agg_dt']), axis=1), 24*file['parent']['agg_dt'])\n daily_std_loads = [np.std(loads[max(i-6, 0):i+6]) for i in range(len(loads))]\n\n composite_day = np.average(loads.reshape(-1, 24*file['parent']['agg_dt']), axis=0)\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=composite_day, name=f\"{name}\", opacity=0.5, showlegend=flag, line={'color':clr, 'width':8, 'dash':dash}))\n\n fig.update_layout(legend=dict(\n yanchor=\"top\",\n y=0.45,\n xanchor=\"left\",\n x=0.7\n ))\n\n fig.update_layout(\n font=dict(\n # family=\"Courier New, monospace\",\n size=65,\n ),\n title=\"Avg Daily Load Profile\",\n xaxis_title=\"Time of Day\",\n yaxis_title=\"Agg. Demand (kW)\"\n )\n\n fig.update_xaxes(\n title_standoff=80\n )\n fig.update_yaxes(\n title_standoff=60\n )\n\n return fig\n\n def plot_max_and_12hravg(self, fig):\n for file in self.files:\n # all_avgs.add_column()\n clr = file['color']\n\n with open(file[\"results\"]) as f:\n data = json.load(f)\n\n name = file[\"name\"]\n ts = len(data['Summary']['p_grid_aggregate'])-1\n rl_setpoint = data['Summary']['p_grid_setpoint']\n if 'clipped' in file['name']:\n rl_setpoint = np.clip(rl_setpoint, 45, 60)\n loads = np.array(data[\"Summary\"][\"p_grid_aggregate\"])\n loads = loads[:len(loads) // (24*file['parent']['agg_dt']) * 24 * file['parent']['agg_dt']]\n if len(loads) > 24:\n daily_max_loads = np.repeat(np.amax(loads.reshape(-1, 24*file['parent']['agg_dt']), axis=1), 24*file['parent']['agg_dt'])\n daily_min_loads = np.repeat(np.amin(loads.reshape(-1, 24*file['parent']['agg_dt']), axis=1), 24*file['parent']['agg_dt'])\n daily_range_loads = np.subtract(daily_max_loads, daily_min_loads)\n daily_range_loads = [abs(loads[max(i-6, 0)] - loads[min(i+6, len(loads)-1)]) for i in range(len(loads))]\n daily_avg_loads = np.repeat(np.mean(loads.reshape(-1, 24*file['parent']['agg_dt']), axis=1), 24*file['parent']['agg_dt'])\n daily_std_loads = np.repeat(np.std(loads.reshape(-1, 24*file['parent']['agg_dt']), axis=1), 24*file['parent']['agg_dt'])\n\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=daily_max_loads, name=f\"{name} - Daily Max\", line_shape='hv', opacity=1, legendgroup=\"first\", line={'color':'firebrick', 'dash':dash, 'width':8}))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=rl_setpoint, name=f\"{name} - 12 Hr Avg\", opacity=0.5, legendgroup=\"second\", line={'color':'blue', 'dash':dash, 'width':8}))\n\n fig.update_layout(legend=dict(\n yanchor=\"top\",\n y=0.8,\n xanchor=\"left\",\n x=0.7\n ))\n\n fig.update_layout(\n font=dict(\n size=65,\n ),\n title=\"12 Hour Avg and Daily Max\",\n yaxis_title=\"Agg. Demand (kW)\"\n )\n\n fig.update_xaxes(\n title_standoff=80\n )\n fig.update_yaxes(\n title_standoff=60\n )\n\n return fig\n\n\n def plot_parametric(self, fig):\n all_daily_stats = PrettyTable(['run name', 'avg daily max', 'std daily max','overall max', 'avg daily range'])\n for file in self.files:\n clr = file['color']\n\n with open(file[\"results\"]) as f:\n data = json.load(f)\n\n name = file[\"name\"]\n ts = len(data['Summary']['p_grid_aggregate'])-1\n rl_setpoint = data['Summary']['p_grid_setpoint']\n if 'clipped' in file['name']:\n rl_setpoint = np.clip(rl_setpoint, 45, 60)\n loads = np.array(data[\"Summary\"][\"p_grid_aggregate\"])\n loads = loads[:len(loads) // (24*file['parent']['agg_dt']) * 24 * file['parent']['agg_dt']]\n if len(loads) >= 24:\n daily_max_loads = np.repeat(np.amax(loads.reshape(-1, 24*file['parent']['agg_dt']), axis=1), 24*file['parent']['agg_dt'])\n daily_min_loads = np.repeat(np.amin(loads.reshape(-1, 24*file['parent']['agg_dt']), axis=1), 24*file['parent']['agg_dt'])\n daily_range_loads = np.subtract(daily_max_loads, daily_min_loads)\n daily_range_loads = [abs(loads[max(i-6, 0)] - loads[min(i+6, len(loads)-1)]) for i in range(len(loads))]\n daily_avg_loads = np.repeat(np.mean(loads.reshape(-1, 24*file['parent']['agg_dt']), axis=1), 24*file['parent']['agg_dt'])\n daily_std_loads = [np.std(loads[max(i-6, 0):i+6]) for i in range(len(loads))]\n\n composite_day = np.average(loads.reshape(-1, 24*file['parent']['agg_dt']), axis=0)\n fig.update_layout(legend=dict(\n yanchor=\"top\",\n y=0.45,\n xanchor=\"left\",\n x=0.5\n ))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=rl_setpoint, name=f\"{name} - 12 Hr Avg\", opacity=0.5, line={'color':clr, 'width':8}))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=data[\"Summary\"][\"p_grid_aggregate\"], name=f\"Agg Load - RL - {name}\", line_shape='hv', line={'color':clr}))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=daily_max_loads, name=f\"{name} - Daily Max\", line_shape='hv', opacity=0.5, line={'color':clr, 'dash':'dot'}))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=daily_min_loads, name=f\"Daily Min Agg Load - RL - {name}\", line_shape='hv', opacity=0.5, line={'color':clr, 'dash':'dash'}))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=daily_range_loads, name=f\"Daily Agg Load Range - RL - {name}\", line_shape='hv', opacity=0.5, line={'color':clr}))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=np.average(daily_range_loads) * np.ones(len(loads)), name=f\"Avg Daily Agg Load Range - RL - {name}\", line_shape='hv', opacity=0.5, line={'color':clr}))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=daily_avg_loads, name=f\"Daily Avg Agg Load - RL - {name}\", line_shape='hv', opacity=0.5, line={'color':clr, 'dash':'dash'}))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=daily_std_loads, name=f\"Daily Std Agg Load - RL - {name}\", line_shape='hv', opacity=0.5, line={'color':clr, 'dash':'dashdot'}))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=np.average(daily_std_loads) * np.ones(len(loads)), name=f\"Avg Daily Std Agg Load - RL - {name}\", line_shape='hv', opacity=0.5, line={'color':clr, 'dash':'dashdot'}))\n fig.add_trace(go.Scatter(x=file['parent']['x_lims'], y=np.cumsum(np.divide(data[\"Summary\"][\"p_grid_aggregate\"],file['parent']['agg_dt'])), name=f\"{name}\", line_shape='hv', visible='legendonly', line={'color':clr, }))\n all_daily_stats.add_row([file['name'], np.average(daily_max_loads), np.std(daily_max_loads), max(daily_max_loads), np.average(daily_range_loads)])\n else:\n self.log.logger.warning(\"Not enough data collected to have daily stats, try running the aggregator for longer.\")\n print(all_daily_stats)\n return fig\n\n def rl2baseline(self, fig):\n if len(self.files) == 0:\n self.log.logger.warning(\"No aggregator runs found for analysis.\")\n return fig\n fig = self.plot_baseline(fig)\n fig = self.plot_parametric(fig)\n fig.update_layout(title_text=\"RL Baseline Comparison\")\n fig.update_layout(\n title=\"Avg Daily Load Profile\",\n xaxis_title=\"Time of Day\",\n yaxis_title=\"Agg. Demand (kWh)\",)\n return fig\n\n def all_rps(self, fig):\n for file in self.files:\n with open(file['results']) as f:\n data = json.load(f)\n\n rps = data['Summary']['RP']\n fig.add_trace(go.Histogram(x=rps, name=f\"{file['name']}\"), row=1, col=1)\n\n with open(file['q_results']) as f:\n data = json.load(f)\n data = data[\"horizon\"]\n mu = np.array(data[\"mu\"])\n std = self.config['agg']['parameters']['exploration_rate'][0]\n delta = np.subtract(mu, rps)\n\n fig.add_trace(go.Histogram(x=delta, name=f\"{file['name']}\"), row=2, col=1)\n fig.add_trace(go.Scatter(x=[-std, -std, std, std], y=[0, 0.3*len(rps), 0.3*len(rps), 0], fill=\"toself\"), row=2, col=1)\n return fig\n\nif __name__ == \"__main__\":\n r = Reformat()\n r.main()\n" ]

[ [ "numpy.clip", "numpy.arange", "numpy.subtract", "numpy.cumsum", "numpy.std", "numpy.average", "numpy.array", "numpy.divide" ] ]

NunoEdgarGFlowHub/entropica_qaoa

[ "bc9496320dbeadeac1302bda056e9d7b67607e30" ]

[ "entropica_qaoa/tests/test_vqe.py" ]

[ "\"\"\"\nTest that all the components of vqe play nicely together\n\"\"\"\n\nimport numpy as np\nimport pytest\nfrom scipy.optimize import minimize\n\nfrom pyquil.paulis import PauliSum, PauliTerm\nfrom pyquil.api import WavefunctionSimulator, local_qvm, get_qc\nfrom pyquil.quil import Program\nfrom pyquil.gates import RX, CNOT\n\nfrom entropica_qaoa.vqe.cost_function import (PrepareAndMeasureOnWFSim,\n PrepareAndMeasureOnQVM)\n\n\n# gonna need this program and hamiltonian for both tests. So define them globally\n# hamiltonian = PauliSum.from_compact_str(\"(-1.0)*Z0*Z1 + 0.8*Z0 + (-0.5)*Z1\")\nterm1 = PauliTerm(\"Z\", 0, -1)\nterm1 *= PauliTerm(\"Z\", 1)\nterm2 = PauliTerm(\"Z\", 0, 0.8)\nterm3 = PauliTerm(\"Z\", 1, -0.5)\nhamiltonian = PauliSum([term1, term2, term3])\n\nprepare_ansatz = Program()\nparams = prepare_ansatz.declare(\"params\", memory_type=\"REAL\", memory_size=4)\nprepare_ansatz.inst(RX(params[0], 0))\nprepare_ansatz.inst(RX(params[1], 1))\nprepare_ansatz.inst(CNOT(0, 1))\nprepare_ansatz.inst(RX(params[2], 0))\nprepare_ansatz.inst(RX(params[3], 1))\n\np0 = [0, 0, 0, 0]\n\n\[email protected]\ndef test_vqe_on_WFSim():\n sim = WavefunctionSimulator()\n cost_fun = PrepareAndMeasureOnWFSim(prepare_ansatz=prepare_ansatz,\n make_memory_map=lambda p: {\"params\": p},\n hamiltonian=hamiltonian,\n sim=sim,\n scalar_cost_function=True)\n\n with local_qvm():\n out = minimize(cost_fun, p0, tol=1e-3, method=\"COBYLA\")\n wf = sim.wavefunction(prepare_ansatz, {\"params\": out['x']})\n assert np.allclose(wf.probabilities(), [0, 0, 0, 1], rtol=1.5, atol=0.01)\n assert np.allclose(out['fun'], -1.3)\n assert out['success']\n\n\[email protected]\ndef test_vqe_on_QVM():\n p0 = [3.1, -1.5, 0, 0] # make it easier when sampling\n qvm = get_qc(\"2q-qvm\")\n with local_qvm():\n cost_fun = PrepareAndMeasureOnQVM(prepare_ansatz=prepare_ansatz,\n make_memory_map=lambda p: {\"params\": p},\n hamiltonian=hamiltonian,\n qvm=qvm,\n scalar_cost_function=True,\n nshots=4,\n base_numshots=50)\n out = minimize(cost_fun, p0, tol=1e-2, method=\"Cobyla\")\n print(out)\n assert np.allclose(out['fun'], -1.3, rtol=1.1)\n assert out['success']\n" ]

[ [ "scipy.optimize.minimize", "numpy.allclose" ] ]

manjavacas/drl-building

[ "6aaa117c0d02b0349af227939460adf31d8d40d9" ]

[ "agents/DQN.py" ]

[ "#!/usr/bin/python3\n\nimport gym\nimport energym\nimport argparse\nimport uuid\nimport mlflow\n\nimport numpy as np\n\nfrom energym.utils.callbacks import LoggerCallback, LoggerEvalCallback\nfrom energym.utils.wrappers import NormalizeObservation, LoggerWrapper\n\nfrom stable_baselines3 import DQN\nfrom stable_baselines3.common.callbacks import EvalCallback, BaseCallback, CallbackList\nfrom stable_baselines3.common.vec_env import DummyVecEnv\n\n\nparser = argparse.ArgumentParser()\nparser.add_argument('--environment', '-env', type=str, default=None)\nparser.add_argument('--episodes', '-ep', type=int, default=1)\nparser.add_argument('--learning_rate', '-lr', type=float, default=0.0001)\nparser.add_argument('--buffer_size', '-bf', type=int, default=1000000)\nparser.add_argument('--learning_starts', '-ls', type=int, default=50000)\nparser.add_argument('--batch_size', '-bs', type=int, default=32)\nparser.add_argument('--tau', '-t', type=float, default=1.0)\nparser.add_argument('--gamma', '-g', type=float, default=.99)\nparser.add_argument('--train_freq', '-tf', type=int, default=4)\nparser.add_argument('--gradient_steps', '-gs', type=int, default=1)\nparser.add_argument('--target_update_interval', '-tu', type=int, default=10000)\nparser.add_argument('--exploration_fraction', '-e', type=float, default=.1)\nparser.add_argument('--exploration_initial_eps', '-ei', type=float, default=1.0)\nparser.add_argument('--exploration_final_eps', '-ef', type=float, default=.05)\nparser.add_argument('--max_grad_norm', '-m', type=float, default=10)\nargs = parser.parse_args()\n\n# experiment ID\nenvironment = args.environment\nn_episodes = args.episodes\nname = 'DQN-' + environment + '-' + str(n_episodes) + '-episodes'\n\nwith mlflow.start_run(run_name=name):\n\n mlflow.log_param('env', environment)\n mlflow.log_param('episodes', n_episodes)\n\n mlflow.log_param('learning_rate', args.learning_rate)\n mlflow.log_param('buffer_size', args.buffer_size)\n mlflow.log_param('learning_starts', args.learning_starts)\n mlflow.log_param('batch_size', args.batch_size)\n mlflow.log_param('tau', args.tau)\n mlflow.log_param('gamma', args.gamma)\n mlflow.log_param('train_freq', args.train_freq)\n mlflow.log_param('gradient_steps', args.gradient_steps)\n mlflow.log_param('target_update_interval', args.target_update_interval)\n mlflow.log_param('exploration_fraction', args.exploration_fraction)\n mlflow.log_param('exploration_initial_eps', args.exploration_initial_eps)\n mlflow.log_param('exploration_final_eps', args.exploration_final_eps)\n mlflow.log_param('max_grad_norm', args.max_grad_norm)\n\n env = gym.make(environment)\n env = NormalizeObservation(LoggerWrapper(env))\n\n #### TRAINING ####\n\n # Build model\n # model = DQN('MlpPolicy', env, verbose=1,\n # learning_rate=args.learning_rate,\n # buffer_size=args.buffer_size,\n # learning_starts=args.learning_starts,\n # batch_size=args.batch_size,\n # tau=args.tau,\n # gamma=args.gamma,\n # train_freq=args.train_freq,\n # gradient_steps=args.gradient_steps,\n # target_update_interval=args.target_update_interval,\n # exploration_fraction=args.exploration_fraction,\n # exploration_initial_eps=args.exploration_initial_eps,\n # exploration_final_eps=args.exploration_final_eps,\n # max_grad_norm=args.max_grad_norm,\n # tensorboard_log='./tensorboard_log/' + name)\n \n # n_timesteps_episode = env.simulator._eplus_one_epi_len / \\\n # env.simulator._eplus_run_stepsize\n # timesteps = n_episodes * n_timesteps_episode + 501\n\n # env = DummyVecEnv([lambda: env])\n # env.env_method('activate_logger')\n\n # # Callbacks\n # freq = 5 # evaluate every N episodes\n # eval_callback = LoggerEvalCallback(env, best_model_save_path='./best_models/' + name + '/',\n # log_path='./best_models/' + name + '/', eval_freq=n_timesteps_episode * freq,\n # deterministic=True, render=False, n_eval_episodes=2)\n # log_callback = LoggerCallback()\n # callback = CallbackList([log_callback, eval_callback])\n\n # # Training\n # model.learn(total_timesteps=timesteps, callback=callback)\n # model.save(name)\n\n #### LOAD MODEL ####\n\n model = DQN.load('best_models/' + name + '/best_model.zip')\n\n for i in range(n_episodes - 1):\n obs = env.reset()\n rewards = []\n done = False\n current_month = 0\n while not done:\n a, _ = model.predict(obs)\n obs, reward, done, info = env.step(a)\n rewards.append(reward)\n if info['month'] != current_month:\n current_month = info['month']\n print(info['month'], sum(rewards))\n print('Episode ', i, 'Mean reward: ', np.mean(rewards), 'Cumulative reward: ', sum(rewards))\n env.close()\n\n mlflow.log_metric('mean_reward', np.mean(rewards))\n mlflow.log_metric('cumulative_reward', sum(rewards))\n\n mlflow.end_run()" ]

[ [ "numpy.mean" ] ]

fontysrobotics/Blackboard_based_distributed_fleet_manager

[ "a6b44738fe67f4948a69f8d45da58d981c6724e0" ]

[ "catkin_ws/simulation/rviz_tools_py-master/src/rviz_tools_py/rviz_tools.py" ]

[ "#!/usr/bin/env python\n\n# Copyright (c) 2015, Carnegie Mellon University\n# All rights reserved.\n# Authors: David Butterworth <[email protected]>\n#\n# Redistribution and use in source and binary forms, with or without\n# modification, are permitted provided that the following conditions are met:\n#\n# - Redistributions of source code must retain the above copyright notice, this\n# list of conditions and the following disclaimer.\n# - Redistributions in binary form must reproduce the above copyright notice,\n# this list of conditions and the following disclaimer in the documentation\n# and/or other materials provided with the distribution.\n# - Neither the name of Carnegie Mellon University nor the names of its\n# contributors may be used to endorse or promote products derived from this\n# software without specific prior written permission.\n#\n# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n# POSSIBILITY OF SUCH DAMAGE.\n\n\n# Python includes\nimport numpy\nimport random # randint\n\n# ROS includes\nimport roslib\nimport rospy\nimport tf # tf/transformations.py\nfrom std_msgs.msg import Header, ColorRGBA\nfrom geometry_msgs.msg import Transform\nfrom geometry_msgs.msg import Pose\nfrom geometry_msgs.msg import Point, Point32\nfrom geometry_msgs.msg import Vector3\nfrom geometry_msgs.msg import Quaternion\nfrom geometry_msgs.msg import Polygon\nfrom visualization_msgs.msg import Marker\n\n\nclass RvizMarkers(object):\n \"\"\"\n A class for publishing markers in Rviz\n \"\"\"\n\n def __init__(self, base_frame, marker_topic, wait_time=None):\n self.base_frame = base_frame\n self.marker_topic = marker_topic\n\n # Set the default Marker parameters\n self.setDefaultMarkerParams()\n\n # Create the Rviz Marker Publisher\n self.loadMarkerPublisher(wait_time)\n\n\n def setDefaultMarkerParams(self):\n \"\"\"\n Set the default parameters for each type of Rviz Marker\n \"\"\"\n\n self.marker_lifetime = rospy.Duration(0.0) # 0 = Marker never expires\n self.muted = False\n self.alpha = 1.0\n\n # Set default parameters for Cylinder Marker\n self.cylinder_marker = Marker()\n self.cylinder_marker.header.frame_id = self.base_frame\n self.cylinder_marker.ns = \"Cylinder\" # unique ID\n self.cylinder_marker.action = Marker().ADD\n self.cylinder_marker.type = Marker().CYLINDER\n self.cylinder_marker.lifetime = self.marker_lifetime\n\n # Reset Marker\n self.reset_marker = Marker()\n self.reset_marker.header.frame_id = self.base_frame\n self.reset_marker.header.stamp = rospy.Time()\n self.reset_marker.action = 3\n\n # Arrow Marker\n self.arrow_marker = Marker()\n self.arrow_marker.header.frame_id = self.base_frame\n self.arrow_marker.ns = \"Arrow\" # unique ID\n self.arrow_marker.action = Marker().ADD\n self.arrow_marker.type = Marker().ARROW\n self.arrow_marker.lifetime = self.marker_lifetime\n\n # Rectangle Marker\n self.rectangle_marker = Marker()\n self.rectangle_marker.header.frame_id = self.base_frame\n self.rectangle_marker.ns = \"Rectangle\" # unique ID\n self.rectangle_marker.action = Marker().ADD\n self.rectangle_marker.type = Marker().CUBE\n self.rectangle_marker.lifetime = self.marker_lifetime\n\n # Line Marker\n self.line_marker = Marker()\n self.line_marker.header.frame_id = self.base_frame\n self.line_marker.ns = \"Line\" # unique ID\n self.line_marker.action = Marker().ADD\n self.line_marker.type = Marker().LINE_STRIP\n self.line_marker.lifetime = self.marker_lifetime\n\n # Path Marker (Line List)\n self.path_marker = Marker()\n self.path_marker.header.frame_id = self.base_frame\n self.path_marker.ns = \"Path\" # unique ID\n self.path_marker.action = Marker().ADD\n self.path_marker.type = Marker().LINE_LIST\n self.path_marker.lifetime = self.marker_lifetime\n self.path_marker.pose.position.x = 0.0\n self.path_marker.pose.position.y = 0.0\n self.path_marker.pose.position.z = 0.0\n self.path_marker.pose.orientation.x = 0.0\n self.path_marker.pose.orientation.y = 0.0\n self.path_marker.pose.orientation.z = 0.0\n self.path_marker.pose.orientation.w = 1.0\n\n # Sphere Marker (A single sphere)\n # This renders a low-quality sphere\n self.sphere_marker = Marker()\n self.sphere_marker.header.frame_id = self.base_frame\n self.sphere_marker.ns = \"Sphere\" # unique ID\n self.sphere_marker.type = Marker().SPHERE\n self.sphere_marker.action = Marker().ADD\n self.sphere_marker.lifetime = self.marker_lifetime\n self.sphere_marker.pose.position.x = 0\n self.sphere_marker.pose.position.y = 0\n self.sphere_marker.pose.position.z = 0\n self.sphere_marker.pose.orientation.x = 0.0\n self.sphere_marker.pose.orientation.y = 0.0\n self.sphere_marker.pose.orientation.z = 0.0\n self.sphere_marker.pose.orientation.w = 1.0\n\n # Sphere Marker #2 (A single sphere)\n # A Sphere List with one sphere, this renders a\n # higher-quality sphere than the method above\n self.sphere_marker2 = Marker()\n self.sphere_marker2.header.frame_id = self.base_frame\n self.sphere_marker2.ns = \"Sphere\" # unique ID\n self.sphere_marker2.type = Marker().SPHERE_LIST\n self.sphere_marker2.action = Marker().ADD\n self.sphere_marker2.lifetime = self.marker_lifetime\n self.sphere_marker2.pose.position.x = 0\n self.sphere_marker2.pose.position.y = 0\n self.sphere_marker2.pose.position.z = 0\n self.sphere_marker2.pose.orientation.x = 0.0\n self.sphere_marker2.pose.orientation.y = 0.0\n self.sphere_marker2.pose.orientation.z = 0.0\n self.sphere_marker2.pose.orientation.w = 1.0\n point1 = Point()\n self.sphere_marker2.points.append(point1)\n self.sphere_marker2.colors.append(self.getColor('blue'))\n\n # Spheres List (Multiple spheres)\n self.spheres_marker = Marker()\n self.spheres_marker.header.frame_id = self.base_frame\n self.spheres_marker.ns = \"Spheres\" # unique ID\n self.spheres_marker.type = Marker().SPHERE_LIST\n self.spheres_marker.action = Marker().ADD\n self.spheres_marker.lifetime = self.marker_lifetime\n self.spheres_marker.pose.position.x = 0.0\n self.spheres_marker.pose.position.y = 0.0\n self.spheres_marker.pose.position.z = 0.0\n self.spheres_marker.pose.orientation.x = 0.0\n self.spheres_marker.pose.orientation.y = 0.0\n self.spheres_marker.pose.orientation.z = 0.0\n self.spheres_marker.pose.orientation.w = 1.0\n\n # Cube Marker (Block or cuboid)\n self.cube_marker = Marker()\n self.cube_marker.header.frame_id = self.base_frame\n self.cube_marker.ns = \"Block\" # unique ID\n self.cube_marker.action = Marker().ADD\n self.cube_marker.type = Marker().CUBE\n self.cube_marker.lifetime = self.marker_lifetime\n\n # Cubes List (Multiple cubes)\n self.cubes_marker = Marker()\n self.cubes_marker.header.frame_id = self.base_frame\n self.cubes_marker.ns = \"Cubes\" # unique ID\n self.cubes_marker.type = Marker().CUBE_LIST\n self.cubes_marker.action = Marker().ADD\n self.cubes_marker.lifetime = self.marker_lifetime\n self.cubes_marker.pose.position.x = 0.0\n self.cubes_marker.pose.position.y = 0.0\n self.cubes_marker.pose.position.z = 0.0\n self.cubes_marker.pose.orientation.x = 0.0\n self.cubes_marker.pose.orientation.y = 0.0\n self.cubes_marker.pose.orientation.z = 0.0\n self.cubes_marker.pose.orientation.w = 1.0\n\n # Cylinder Marker\n self.cylinder_marker = Marker()\n self.cylinder_marker.header.frame_id = self.base_frame\n self.cylinder_marker.ns = \"Cylinder\" # unique ID\n self.cylinder_marker.action = Marker().ADD\n self.cylinder_marker.type = Marker().CYLINDER\n self.cylinder_marker.lifetime = self.marker_lifetime\n\n # Mesh Marker\n self.mesh_marker = Marker()\n self.mesh_marker.header.frame_id = self.base_frame\n self.mesh_marker.ns = \"Mesh\" # unique ID\n self.mesh_marker.action = Marker().ADD\n self.mesh_marker.type = Marker().MESH_RESOURCE\n self.mesh_marker.lifetime = self.marker_lifetime\n\n # Text Marker\n self.text_marker = Marker()\n self.text_marker.header.frame_id = self.base_frame\n self.text_marker.ns = \"Text\" # unique ID\n self.text_marker.action = Marker().ADD\n self.text_marker.type = Marker().TEXT_VIEW_FACING\n self.text_marker.lifetime = self.marker_lifetime\n\n\n def loadMarkerPublisher(self, wait_time=None):\n \"\"\"\n Initialize the ROS Publisher.\n\n If wait_time != None, wait for specified number of\n seconds for a subscriber to connect.\n \"\"\"\n\n # Check if the ROS Publisher has already been created\n if hasattr(self, 'pub_rviz_marker'):\n return\n\n # Create the Rviz Marker Publisher\n self.pub_rviz_marker = rospy.Publisher(self.marker_topic, Marker, queue_size=10)\n rospy.logdebug(\"Publishing Rviz markers on topic '%s'\", self.marker_topic)\n\n # Block for specified number of seconds,\n # or until there is 1 subscriber\n if wait_time != None:\n self.waitForSubscriber(self.pub_rviz_marker, wait_time)\n\n\n def waitForSubscriber(self, publisher, wait_time=1.0):\n \"\"\"\n Wait until there is 1 subscriber to a ROS Publisher,\n or until some number of seconds have elapsed.\n \"\"\"\n\n start_time = rospy.Time.now()\n max_time = start_time + rospy.Duration(wait_time)\n\n num_existing_subscribers = publisher.get_num_connections()\n\n while (num_existing_subscribers == 0):\n #print 'Number of subscribers: ', num_existing_subscribers\n rospy.Rate(100).sleep()\n\n if (rospy.Time.now() > max_time):\n rospy.logerr(\"No subscribers connected to the '%s' topic after %f seconds\", self.marker_topic, wait_time)\n return False\n\n num_existing_subscribers = publisher.get_num_connections()\n\n return True\n\n\n def publishMarker(self, marker):\n \"\"\"\n Publish a Marker Msg\n \"\"\"\n\n if (self.muted == True):\n return True\n\n ## Check ROS Publisher\n #self.loadMarkerPublisher()\n\n self.pub_rviz_marker.publish(marker)\n\n return True\n\n\n def deleteAllMarkers(self):\n \"\"\"\n Publish a Msg to delete all Markers\n \"\"\"\n\n return self.publishMarker(self.reset_marker)\n\n\n def getColor(self, color):\n \"\"\"\n Convert a color name or RGB value to a ROS ColorRGBA type\n\n @param color name (string) or RGB color value (tuple or list)\n\n @return color (ColorRGBA)\n \"\"\"\n\n result = ColorRGBA()\n result.a = self.alpha\n\n if (type(color) == tuple) or (type(color) == list):\n if len(color) == 3:\n result.r = color[0]\n result.g = color[1]\n result.b = color[2]\n elif len(color) == 4:\n result.r = color[0]\n result.g = color[1]\n result.b = color[2]\n result.a = color[3]\n else:\n raise ValueError('color must have 3 or 4 float values in getColor()')\n elif (color == 'red'):\n result.r = 0.8\n result.g = 0.1\n result.b = 0.1\n elif (color == 'green'):\n result.r = 0.1\n result.g = 0.8\n result.b = 0.1\n elif (color == 'blue'):\n result.r = 0.1\n result.g = 0.1\n result.b = 0.8\n elif (color == 'grey') or (color == 'gray'):\n result.r = 0.9\n result.g = 0.9\n result.b = 0.9\n elif (color == 'white'):\n result.r = 1.0\n result.g = 1.0\n result.b = 1.0\n elif (color == 'orange'):\n result.r = 1.0\n result.g = 0.5\n result.b = 0.0\n elif (color == 'translucent_light'):\n result.r = 0.1\n result.g = 0.1\n result.b = 0.1\n result.a = 0.1\n elif (color == 'translucent'):\n result.r = 0.1\n result.g = 0.1\n result.b = 0.1\n result.a = 0.25\n elif (color == 'translucent_dark'):\n result.r = 0.1\n result.g = 0.1\n result.b = 0.1\n result.a = 0.5\n elif (color == 'black'):\n result.r = 0.0\n result.g = 0.0\n result.b = 0.0\n elif (color == 'yellow'):\n result.r = 1.0\n result.g = 1.0\n result.b = 0.0\n elif (color == 'brown'):\n result.r = 0.597\n result.g = 0.296\n result.b = 0.0\n elif (color == 'pink'):\n result.r = 1.0\n result.g = 0.4\n result.b = 1\n elif (color == 'lime_green'):\n result.r = 0.6\n result.g = 1.0\n result.b = 0.2\n elif (color == 'clear'):\n result.r=1.0\n result.g=1.0\n result.b=1.0\n result.a=0.0\n elif (color == 'purple'):\n result.r = 0.597\n result.g = 0.0\n result.b = 0.597\n elif (color == 'random'):\n # Get a random color that is not too light\n while True:\n result.r = random.random() # random float from 0 to 1\n result.g = random.random()\n result.b = random.random()\n if ((result.r + result.g + result.b) > 1.5): # 0=black, 3=white\n break\n else:\n rospy.logerr(\"getColor() called with unknown color name '%s', defaulting to 'blue'\", color)\n result.r = 0.1\n result.g = 0.1\n result.b = 0.8\n\n return result \n\n\n def getRandomColor(self):\n \"\"\"\n Get a random color.\n\n @return color (ColorRGBA)\n \"\"\"\n\n # Make a list of the color names to choose from\n all_colors = []\n all_colors.append('red')\n all_colors.append('green')\n all_colors.append('blue')\n all_colors.append('grey')\n all_colors.append('white')\n all_colors.append('orange')\n all_colors.append('yellow')\n all_colors.append('brown')\n all_colors.append('pink')\n all_colors.append('lime_green')\n all_colors.append('purple')\n\n # Chose a random color name\n rand_num = random.randint(0, len(all_colors) - 1)\n rand_color_name = all_colors[rand_num]\n\n return rand_color_name\n\n\n def publishSphere(self, pose, color, scale, lifetime=None):\n \"\"\"\n Publish a sphere Marker. This renders 3D looking sphere.\n\n @param pose (numpy matrix, numpy ndarray, ROS Pose)\n @param color name (string) or RGB color value (tuple or list)\n @param scale (ROS Vector3, float)\n @param lifetime (float, None = never expire)\n \"\"\"\n\n if (self.muted == True):\n return True\n\n # Convert input pose to a ROS Pose Msg\n if (type(pose) == numpy.matrix) or (type(pose) == numpy.ndarray):\n sphere_pose = mat_to_pose(pose)\n elif type(pose) == Pose:\n sphere_pose = pose\n elif type(pose) == Point:\n pose_msg = Pose()\n pose_msg.position = pose\n sphere_pose = pose_msg\n else:\n rospy.logerr(\"Pose is unsupported type '%s' in publishSphere()\", type(pose).__name__)\n return False\n\n # Convert input scale to a ROS Vector3 Msg\n if type(scale) == Vector3:\n sphere_scale = scale\n elif type(scale) == float:\n sphere_scale = Vector3(scale, scale, scale)\n else:\n rospy.logerr(\"Scale is unsupported type '%s' in publishSphere()\", type(scale).__name__)\n return False\n\n # Increment the ID number\n self.sphere_marker.id += 1\n\n # Get the default parameters\n sphere_marker = self.sphere_marker\n\n if lifetime == None:\n sphere_marker.lifetime = rospy.Duration(0.0) # 0 = Marker never expires\n else:\n sphere_marker.lifetime = rospy.Duration(lifetime) # in seconds\n\n # Set the timestamp\n sphere_marker.header.stamp = rospy.Time.now()\n\n # Set marker size\n sphere_marker.scale = sphere_scale\n\n # Set marker color\n sphere_marker.color = self.getColor(color)\n\n # Set the pose\n sphere_marker.pose = sphere_pose\n\n return self.publishMarker(sphere_marker)\n\n\n def publishSphere2(self, pose, color, scale, lifetime=None):\n \"\"\"\n Publish a sphere Marker. This renders a smoother, flatter-looking sphere.\n\n @param pose (numpy matrix, numpy ndarray, ROS Pose)\n @param color name (string) or RGB color value (tuple or list)\n @param scale (ROS Vector3, float)\n @param lifetime (float, None = never expire)\n \"\"\"\n\n if (self.muted == True):\n return True\n\n # Convert input pose to a ROS Pose Msg\n if (type(pose) == numpy.matrix) or (type(pose) == numpy.ndarray):\n sphere_pose = mat_to_pose(pose)\n elif type(pose) == Pose:\n sphere_pose = pose\n elif type(pose) == Point:\n pose_msg = Pose()\n pose_msg.position = pose\n sphere_pose = pose_msg\n else:\n rospy.logerr(\"Pose is unsupported type '%s' in publishSphere()\", type(pose).__name__)\n return False\n\n # Convert input scale to a ROS Vector3 Msg\n if type(scale) == Vector3:\n sphere_scale = scale\n elif type(scale) == float:\n sphere_scale = Vector3(scale, scale, scale)\n else:\n rospy.logerr(\"Scale is unsupported type '%s' in publishSphere()\", type(scale).__name__)\n return False\n\n # Increment the ID number\n self.sphere_marker.id += 1\n\n # Get the default parameters\n sphere_marker = self.sphere_marker2 # sphere_marker2 = SPHERE_LIST\n\n if lifetime == None:\n sphere_marker.lifetime = rospy.Duration(0.0) # 0 = Marker never expires\n else:\n sphere_marker.lifetime = rospy.Duration(lifetime) # in seconds\n\n # Set the timestamp\n sphere_marker.header.stamp = rospy.Time.now()\n\n # Set marker size\n sphere_marker.scale = sphere_scale\n\n # Set marker color\n sphere_marker.color = self.getColor(color)\n\n # Set the pose of one sphere in the list\n sphere_marker.points[0] = sphere_pose.position\n sphere_marker.colors[0] = self.getColor(color)\n\n return self.publishMarker(sphere_marker)\n\n\n def publishArrow(self, pose, color, scale, lifetime=None):\n \"\"\"\n Publish an arrow Marker.\n\n @param pose (numpy matrix, numpy ndarray, ROS Pose)\n @param color name (string) or RGB color value (tuple or list)\n @param scale (ROS Vector3, float)\n @param lifetime (float, None = never expire)\n \"\"\"\n\n if (self.muted == True):\n return True\n\n # Convert input pose to a ROS Pose Msg\n if (type(pose) == numpy.matrix) or (type(pose) == numpy.ndarray):\n arrow_pose = mat_to_pose(pose)\n elif type(pose) == Pose:\n arrow_pose = pose\n else:\n rospy.logerr(\"Pose is unsupported type '%s' in publishArrow()\", type(pose).__name__)\n return False\n\n # Convert input scale to a ROS Vector3 Msg\n if type(scale) == Vector3:\n arrow_scale = scale\n elif type(scale) == float:\n arrow_scale = Vector3(scale, 0.1*scale, 0.1*scale)\n else:\n rospy.logerr(\"Scale is unsupported type '%s' in publishArrow()\", type(scale).__name__)\n return False\n\n # Increment the ID number\n self.arrow_marker.id += 1\n\n # Get the default parameters\n arrow_marker = self.arrow_marker\n\n if lifetime == None:\n arrow_marker.lifetime = rospy.Duration(0.0) # 0 = Marker never expires\n else:\n arrow_marker.lifetime = rospy.Duration(lifetime) # in seconds\n\n # Set the timestamp\n arrow_marker.header.stamp = rospy.Time.now()\n\n # Set the pose\n arrow_marker.pose = arrow_pose\n\n # Set marker size\n arrow_marker.scale = arrow_scale\n\n # Set marker color\n arrow_marker.color = self.getColor(color)\n\n return self.publishMarker(arrow_marker)\n\n\n def publishCube(self, pose, color, scale, lifetime=None):\n \"\"\"\n Publish a cube Marker.\n\n @param pose (numpy matrix, numpy ndarray, ROS Pose)\n @param color name (string) or RGB color value (tuple or list)\n @param scale (ROS Vector3, float)\n @param lifetime (float, None = never expire)\n \"\"\"\n\n if (self.muted == True):\n return True\n\n # Convert input pose to a ROS Pose Msg\n if (type(pose) == numpy.matrix) or (type(pose) == numpy.ndarray):\n cube_pose = mat_to_pose(pose)\n elif type(pose) == Pose:\n cube_pose = pose\n else:\n rospy.logerr(\"Pose is unsupported type '%s' in publishCube()\", type(pose).__name__)\n return False\n\n # Convert input scale to a ROS Vector3 Msg\n if type(scale) == Vector3:\n cube_scale = scale\n elif type(scale) == float:\n cube_scale = Vector3(scale, scale, scale)\n else:\n rospy.logerr(\"Scale is unsupported type '%s' in publishCube()\", type(scale).__name__)\n return False\n\n # Increment the ID number\n self.cube_marker.id += 1\n\n # Get the default parameters\n cube_marker = self.cube_marker\n\n if lifetime == None:\n cube_marker.lifetime = rospy.Duration(0.0) # 0 = Marker never expires\n else:\n cube_marker.lifetime = rospy.Duration(lifetime) # in seconds\n\n # Set the timestamp\n cube_marker.header.stamp = rospy.Time.now()\n\n # Set the pose\n cube_marker.pose = cube_pose\n\n # Set marker size\n cube_marker.scale = cube_scale\n\n # Set marker color\n cube_marker.color = self.getColor(color)\n\n return self.publishMarker(cube_marker)\n\n\n def publishCubes(self, list_of_cubes, color, scale, lifetime=None):\n \"\"\"\n Publish a list of cubes.\n\n @param list_of_cubes (list of numpy matrix, list of numpy ndarray, list of ROS Pose)\n @param color name (string) or RGB color value (tuple or list)\n @param scale (ROS Vector3, float)\n @param lifetime (float, None = never expire)\n \"\"\"\n\n if (self.muted == True):\n return True\n\n # Check input\n if type(list_of_cubes) != list:\n rospy.logerr(\"list_of_cubes is unsupported type '%s' in publishCubes()\", type(list_of_cubes).__name__)\n return False\n\n # Convert input scale to a ROS Vector3 Msg\n if type(scale) == Vector3:\n cubes_scale = scale\n elif type(scale) == float:\n cubes_scale = Vector3(scale, scale, scale)\n else:\n rospy.logerr(\"Scale is unsupported type '%s' in publishCubes()\", type(scale).__name__)\n return False\n\n # Increment the ID number\n self.cubes_marker.id += 1\n\n # Get the default parameters\n cubes_marker = self.cubes_marker\n\n if lifetime == None:\n cubes_marker.lifetime = rospy.Duration(0.0) # 0 = Marker never expires\n else:\n cubes_marker.lifetime = rospy.Duration(lifetime) # in seconds\n\n # Set the timestamp\n cubes_marker.header.stamp = rospy.Time.now()\n\n # Set marker size\n cubes_marker.scale = cubes_scale\n\n # Set marker color\n cubes_marker.color = self.getColor(color)\n\n cubes_color = self.getColor(color)\n\n # Set the cubes positions and color\n cubes_marker.points[:] = [] # clear\n cubes_marker.colors[:] = []\n for i in range(0, len(list_of_cubes)):\n\n # Each cube position needs to be a ROS Point Msg\n if type(list_of_cubes[i]) == Pose:\n cubes_marker.points.append(list_of_cubes[i].position)\n cubes_marker.colors.append(cubes_color)\n elif (type(list_of_cubes[i]) == numpy.matrix) or (type(list_of_cubes[i]) == numpy.ndarray):\n pose_i = mat_to_pose(list_of_cubes[i])\n cubes_marker.points.append(pose_i.position)\n cubes_marker.colors.append(cubes_color)\n elif type(list_of_cubes[i]) == Point:\n cubes_marker.points.append(list_of_cubes[i])\n cubes_marker.colors.append(cubes_color)\n else:\n rospy.logerr(\"list_of_cubes contains unsupported type '%s' in publishCubes()\", type(list_of_cubes[i]).__name__)\n return False\n\n return self.publishMarker(cubes_marker)\n\n\n def publishBlock(self, pose, color, scale, lifetime=None):\n \"\"\"\n Publish a cube Marker.\n\n @param pose (numpy matrix, numpy ndarray, ROS Pose)\n @param color name (string) or RGB color value (tuple or list)\n @param scale (ROS Vector3, float)\n @param lifetime (float, None = never expire)\n \"\"\"\n\n return self.publishCube(pose, color, scale)\n\n\n def publishCylinder(self, pose, color, height, radius, lifetime=None):\n \"\"\"\n Publish a cylinder Marker.\n\n @param pose (numpy matrix, numpy ndarray, ROS Pose)\n @param color name (string) or RGB color value (tuple or list)\n @param height (float)\n @param radius (float)\n @param lifetime (float, None = never expire)\n \"\"\"\n\n if (self.muted == True):\n return True\n\n # Convert input pose to a ROS Pose Msg\n if (type(pose) == numpy.matrix) or (type(pose) == numpy.ndarray):\n cylinder_pose = mat_to_pose(pose)\n elif type(pose) == Pose:\n cylinder_pose = pose\n else:\n rospy.logerr(\"Pose is unsupported type '%s' in publishCylinder()\", type(pose).__name__)\n return False\n\n # Increment the ID number\n self.cylinder_marker.id += 1\n\n # Get the default parameters\n cylinder_marker = self.cylinder_marker\n\n if lifetime == None:\n cylinder_marker.lifetime = rospy.Duration(0.0) # 0 = Marker never expires\n else:\n cylinder_marker.lifetime = rospy.Duration(lifetime) # in seconds\n\n # Set the timestamp\n cylinder_marker.header.stamp = rospy.Time.now()\n\n # Set the pose\n cylinder_marker.pose = cylinder_pose\n\n # Set marker size\n cylinder_marker.scale.x = radius\n cylinder_marker.scale.y = radius\n cylinder_marker.scale.z = height\n\n # Set marker color\n cylinder_marker.color = self.getColor(color)\n\n return self.publishMarker(cylinder_marker)\n\n\n def publishAxis(self, pose, length, radius, lifetime=None):\n \"\"\"\n Publish an axis Marker.\n\n @param pose (numpy matrix, numpy ndarray, ROS Pose)\n @param length axis length (float)\n @param radius axis radius (float)\n @param lifetime (float, None = never expire)\n \"\"\"\n\n # Convert input pose to a numpy matrix\n if (type(pose) == numpy.matrix) or (type(pose) == numpy.ndarray):\n axis_pose = pose\n elif type(pose) == Pose:\n axis_pose = pose_to_mat(pose)\n else:\n rospy.logerr(\"Pose is unsupported type '%s' in publishAxis()\", type(pose).__name__)\n return False\n\n t = tf.transformations.translation_matrix( (length/2.0, 0.0, 0.0) )\n r = tf.transformations.rotation_matrix(numpy.pi/2.0, (0,1,0))\n m = tf.transformations.concatenate_matrices(axis_pose, t, r)\n x_pose = mat_to_pose(m)\n self.publishCylinder(x_pose, 'red', length, radius, lifetime)\n\n t = tf.transformations.translation_matrix( (0.0, length/2.0, 0.0) )\n r = tf.transformations.rotation_matrix(numpy.pi/2.0, (1,0,0))\n m = tf.transformations.concatenate_matrices(axis_pose, t, r)\n y_pose = mat_to_pose(m)\n self.publishCylinder(y_pose, 'green', length, radius, lifetime)\n\n t = tf.transformations.translation_matrix( (0.0, 0.0, length/2.0) )\n r = tf.transformations.rotation_matrix(0.0, (0,0,1))\n m = tf.transformations.concatenate_matrices(axis_pose, t, r)\n z_pose = mat_to_pose(m)\n self.publishCylinder(z_pose, 'blue', length, radius, lifetime)\n\n return True\n\n\n def publishMesh(self, pose, file_name, color, scale, lifetime=None):\n \"\"\"\n Publish a mesh Marker. The mesh file can be a binary STL or collada DAE file.\n\n @param pose (numpy matrix, numpy ndarray, ROS Pose)\n @param file_name (string)\n @param color name (string) or RGB color value (tuple or list)\n @param scale (ROS Vector3, float)\n @param lifetime (float, None = never expire)\n \"\"\"\n\n if (self.muted == True):\n return True\n\n # Convert input pose to a ROS Pose Msg\n if (type(pose) == numpy.matrix) or (type(pose) == numpy.ndarray):\n mesh_pose = mat_to_pose(pose)\n elif type(pose) == Pose:\n mesh_pose = pose\n else:\n rospy.logerr(\"Pose is unsupported type '%s' in publishMesh()\", type(pose).__name__)\n return False\n\n # Convert input scale to a ROS Vector3 Msg\n if type(scale) == Vector3:\n mesh_scale = scale\n elif type(scale) == float:\n mesh_scale = Vector3(scale, scale, scale)\n else:\n rospy.logerr(\"Scale is unsupported type '%s' in publishMesh()\", type(scale).__name__)\n return False\n\n # Increment the ID number\n self.mesh_marker.id += 1\n\n # Get the default parameters\n mesh_marker = self.mesh_marker\n\n if lifetime == None:\n mesh_marker.lifetime = rospy.Duration(0.0) # 0 = Marker never expires\n else:\n mesh_marker.lifetime = rospy.Duration(lifetime) # in seconds\n\n # Set the timestamp\n mesh_marker.header.stamp = rospy.Time.now()\n\n # Set marker size\n mesh_marker.scale = mesh_scale\n\n # Set marker color\n if color == None:\n mesh_marker.color = ColorRGBA() # no color\n else:\n mesh_marker.color = self.getColor(color)\n\n # Set the pose\n mesh_marker.pose = mesh_pose\n\n # Set the mesh\n mesh_marker.mesh_resource = file_name\n mesh_marker.mesh_use_embedded_materials = True\n\n return self.publishMarker(mesh_marker)\n\n\n def publishRectangle(self, point1, point2, color, lifetime=None):\n \"\"\"\n Publish a rectangle Marker between two points. If the z-values are not the same then this will result in a cuboid.\n\n @param point1 (ROS Point)\n @param point2 (ROS Point)\n @param color name (string) or RGB color value (tuple or list)\n @param lifetime (float, None = never expire)\n \"\"\"\n\n if (self.muted == True):\n return True\n\n # Convert input points to ROS Point Msgs\n if type(point1) == Point:\n rect_point1 = point1\n else:\n rospy.logerr(\"Point1 is unsupported type '%s' in publishRectangle()\", type(point1).__name__)\n return False\n if type(point2) == Point:\n rect_point2 = point2\n else:\n rospy.logerr(\"Point2 is unsupported type '%s' in publishRectangle()\", type(point2).__name__)\n return False\n\n # Increment the ID number\n self.rectangle_marker.id += 1\n\n # Get the default parameters\n rectangle_marker = self.rectangle_marker\n\n if lifetime == None:\n rectangle_marker.lifetime = rospy.Duration(0.0) # 0 = Marker never expires\n else:\n rectangle_marker.lifetime = rospy.Duration(lifetime) # in seconds\n\n # Set the timestamp\n rectangle_marker.header.stamp = rospy.Time.now()\n\n # Set marker color\n rectangle_marker.color = self.getColor(color)\n\n # Calculate the center pose\n rect_pose = Pose()\n rect_pose.position.x = (rect_point1.x - rect_point2.x) / 2.0 + rect_point2.x\n rect_pose.position.y = (rect_point1.y - rect_point2.y) / 2.0 + rect_point2.y\n rect_pose.position.z = (rect_point1.z - rect_point2.z) / 2.0 + rect_point2.z\n rectangle_marker.pose = rect_pose\n\n # Calculate scale\n rectangle_marker.scale.x = numpy.fabs(rect_point1.x - rect_point2.x)\n rectangle_marker.scale.y = numpy.fabs(rect_point1.y - rect_point2.y)\n rectangle_marker.scale.z = numpy.fabs(rect_point1.z - rect_point2.z)\n\n return self.publishMarker(rectangle_marker)\n\n\n def publishPlane(self, pose, depth, width, color, lifetime=None):\n \"\"\"\n Publish a plane Marker.\n\n @param pose (numpy matrix, numpy ndarray, ROS Pose)\n @param depth (float)\n @param width (float)\n @param color name (string) or RGB color value (tuple or list)\n @param lifetime (float, None = never expire)\n \"\"\"\n\n if (self.muted == True):\n return True\n\n # Convert input pose to a ROS Pose Msg\n if (type(pose) == numpy.matrix) or (type(pose) == numpy.ndarray):\n rect_pose = mat_to_pose(pose)\n elif type(pose) == Pose:\n rect_pose = pose\n else:\n rospy.logerr(\"Pose is unsupported type '%s' in publishRectangle()\", type(pose).__name__)\n return False\n\n # Increment the ID number\n self.rectangle_marker.id += 1\n\n # Get the default parameters\n rectangle_marker = self.rectangle_marker\n\n if lifetime == None:\n rectangle_marker.lifetime = rospy.Duration(0.0) # 0 = Marker never expires\n else:\n rectangle_marker.lifetime = rospy.Duration(lifetime) # in seconds\n\n # Set the timestamp\n rectangle_marker.header.stamp = rospy.Time.now()\n\n # Set marker color\n rectangle_marker.color = self.getColor(color)\n\n # Set the pose\n rectangle_marker.pose = rect_pose\n\n # Set the scale\n rectangle_marker.scale.x = depth\n rectangle_marker.scale.y = width\n rectangle_marker.scale.z = 0.0\n\n return self.publishMarker(rectangle_marker)\n\n\n def publishLine(self, point1, point2, color, width, lifetime=None):\n \"\"\"\n Publish a line Marker between two points.\n\n @param point1 (ROS Point, ROS Pose, numpy matrix, numpy ndarray)\n @param point2 (ROS Point, ROS Pose, numpy matrix, numpy ndarray)\n @param color name (string) or RGB color value (tuple or list)\n @param width (float)\n @param lifetime (float, None = never expire)\n \"\"\"\n\n if (self.muted == True):\n return True\n\n # Convert input points to ROS Point Msgs\n if type(point1) == Point:\n line_point1 = point1\n elif type(point1) == Pose:\n position = point1.position\n line_point1 = Point(position.x, position.y, position.z)\n elif (type(point1) == numpy.matrix) or (type(point1) == numpy.ndarray):\n pose = mat_to_pose(point1)\n position = pose.position\n line_point1 = Point(position.x, position.y, position.z)\n else:\n rospy.logerr(\"Point1 is unsupported type '%s' in publishLine()\", type(point1).__name__)\n return False\n\n if type(point2) == Point:\n line_point2 = point2\n elif type(point2) == Pose:\n position = point2.position\n line_point2 = Point(position.x, position.y, position.z)\n elif (type(point2) == numpy.matrix) or (type(point2) == numpy.ndarray):\n pose = mat_to_pose(point2)\n position = pose.position\n line_point2 = Point(position.x, position.y, position.z)\n else:\n rospy.logerr(\"Point2 is unsupported type '%s' in publishLine()\", type(point2).__name__)\n return False\n\n # Increment the ID number\n self.line_marker.id += 1\n\n # Get the default parameters\n line_marker = self.line_marker\n\n if lifetime == None:\n line_marker.lifetime = rospy.Duration(0.0) # 0 = Marker never expires\n else:\n line_marker.lifetime = rospy.Duration(lifetime) # in seconds\n\n # Set the timestamp\n line_marker.header.stamp = rospy.Time.now()\n\n # Set marker color\n line_marker.color = self.getColor(color)\n\n # Set the start and end points\n line_marker.points[:] = [] # clear\n line_marker.points.append(line_point1)\n line_marker.points.append(line_point2)\n\n # Set the line width\n line_marker.scale.x = width\n\n return self.publishMarker(line_marker)\n\n\n def publishPath(self, path, color, width, lifetime=None):\n \"\"\"\n Publish a path Marker using a set of waypoints.\n\n @param path (list of ROS Points)\n @param color name (string) or RGB color value (tuple or list)\n @param width (float)\n @param lifetime (float, None = never expire)\n \"\"\"\n\n if (self.muted == True):\n return True\n\n # Check input\n if type(path) == list:\n path_path = path # :-)\n else:\n rospy.logerr(\"Path is unsupported type '%s' in publishPath()\", type(path).__name__)\n return False\n\n # Increment the ID number\n self.path_marker.id += 1\n\n # Get the default parameters\n path_marker = self.path_marker\n\n if lifetime == None:\n path_marker.lifetime = rospy.Duration(0.0) # 0 = Marker never expires\n else:\n path_marker.lifetime = rospy.Duration(lifetime) # in seconds\n\n # Set the timestamp\n path_marker.header.stamp = rospy.Time.now()\n\n # Set the path width\n path_marker.scale.x = width\n\n path_color = self.getColor(color)\n\n # Set the path points and color\n path_marker.points[:] = [] # clear\n path_marker.colors[:] = []\n for i in range(1, len(path)):\n\n # Each path waypoint needs to be a ROS Point Msg\n if type(path[i]) == Point:\n # Start of segment is previous point\n path_marker.points.append(path[i-1])\n path_marker.colors.append(path_color)\n # End of segment is current point\n path_marker.points.append(path[i])\n path_marker.colors.append(path_color)\n elif type(path[i]) == Pose:\n # Start of segment is previous point\n position = path[i-1].position\n point = Point(position.x, position.y, position.z)\n path_marker.points.append(point)\n path_marker.colors.append(path_color)\n # End of segment is current point\n position = path[i].position\n point = Point(position.x, position.y, position.z)\n path_marker.points.append(point)\n path_marker.colors.append(path_color)\n elif (type(path[i]) == numpy.matrix) or (type(path[i]) == numpy.ndarray):\n # Start of segment is previous point\n pose = mat_to_pose(path[i-1])\n position = pose.position\n point = Point(position.x, position.y, position.z)\n path_marker.points.append(point)\n path_marker.colors.append(path_color)\n # End of segment is current point\n pose = mat_to_pose(path[i])\n position = pose.position\n point = Point(position.x, position.y, position.z)\n path_marker.points.append(point)\n path_marker.colors.append(path_color) \n else:\n rospy.logerr(\"path list contains unsupported type '%s' in publishPath()\", type(path[i]).__name__)\n return False\n\n return self.publishMarker(path_marker)\n\n\n def publishPolygon(self, polygon, color, width, lifetime=None):\n \"\"\"\n Publish a polygon Marker.\n\n @param polygon (ROS Polygon)\n @param color name (string) or RGB color value (tuple or list)\n @param width line width (float)\n @param lifetime (float, None = never expire)\n\n a path with the start and end points connected\n \"\"\"\n\n if (self.muted == True):\n return True\n\n # Check input\n if type(polygon) == Polygon:\n polygon_msg = polygon\n else:\n rospy.logerr(\"Path is unsupported type '%s' in publishPolygon()\", type(polygon).__name__)\n return False\n\n # Copy points from ROS Polygon Msg into a list\n polygon_path = []\n for i in range(0, len(polygon_msg.points)):\n x = polygon_msg.points[i].x\n y = polygon_msg.points[i].y\n z = polygon_msg.points[i].z\n polygon_path.append( Point(x,y,z) )\n\n # Add the first point again\n x = polygon_msg.points[0].x\n y = polygon_msg.points[0].y\n z = polygon_msg.points[0].z\n polygon_path.append( Point(x,y,z) )\n\n return self.publishPath(polygon_path, color, width, lifetime)\n\n\n def publishSpheres(self, list_of_spheres, color, scale, lifetime=None):\n \"\"\"\n Publish a list of spheres. This renders smoother, flatter-looking spheres.\n\n @param list_of_spheres (list of numpy matrix, list of numpy ndarray, list of ROS Pose)\n @param color name (string) or RGB color value (tuple or list)\n @param scale (ROS Vector3, float)\n @param lifetime (float, None = never expire)\n \"\"\"\n\n if (self.muted == True):\n return True\n\n # Check input\n if type(list_of_spheres) != list:\n rospy.logerr(\"list_of_spheres is unsupported type '%s' in publishSpheres()\", type(list_of_spheres).__name__)\n return False\n\n # Convert input scale to a ROS Vector3 Msg\n if type(scale) == Vector3:\n spheres_scale = scale\n elif type(scale) == float:\n spheres_scale = Vector3(scale, scale, scale)\n else:\n rospy.logerr(\"Scale is unsupported type '%s' in publishSpheres()\", type(scale).__name__)\n return False\n\n # Increment the ID number\n self.spheres_marker.id += 1\n\n # Get the default parameters\n spheres_marker = self.spheres_marker\n\n if lifetime == None:\n spheres_marker.lifetime = rospy.Duration(0.0) # 0 = Marker never expires\n else:\n spheres_marker.lifetime = rospy.Duration(lifetime) # in seconds\n\n # Set the timestamp\n spheres_marker.header.stamp = rospy.Time.now()\n\n # Set marker size\n spheres_marker.scale = spheres_scale\n\n # Set marker color\n spheres_marker.color = self.getColor(color)\n\n spheres_color = self.getColor(color)\n #spheres_marker.color = spheres_color\n\n # Set the sphere positions and color\n spheres_marker.points[:] = [] # clear\n spheres_marker.colors[:] = []\n for i in range(0, len(list_of_spheres)):\n\n # Each sphere position needs to be a ROS Point Msg\n if type(list_of_spheres[i]) == Pose:\n spheres_marker.points.append( list_of_spheres[i].position ) \n spheres_marker.colors.append(spheres_color)\n elif (type(list_of_spheres[i]) == numpy.matrix) or (type(list_of_spheres[i]) == numpy.ndarray):\n pose_i = mat_to_pose(list_of_spheres[i])\n spheres_marker.points.append( pose_i.position )\n spheres_marker.colors.append(spheres_color)\n elif type(list_of_spheres[i]) == Point:\n spheres_marker.points.append(list_of_spheres[i])\n spheres_marker.colors.append(spheres_color)\n else:\n rospy.logerr(\"list_of_sphere contains unsupported type '%s' in publishSphere()\", type(list_of_spheres[i]).__name__)\n return False\n\n return self.publishMarker(spheres_marker)\n\n\n def publishText(self, pose, text, color, scale, lifetime=None):\n \"\"\"\n Publish a text Marker\n\n @param pose (numpy matrix, numpy ndarray, ROS Pose)\n @param text (string)\n @param color name (string) or RGB color value (tuple or list)\n @param scale (ROS Vector3, float)\n @param lifetime (float, None = never expire)\n \"\"\"\n\n if (self.muted == True):\n return True\n\n # Convert input pose to a ROS Pose Msg\n if (type(pose) == numpy.matrix) or (type(pose) == numpy.ndarray):\n text_pose = mat_to_pose(pose)\n elif type(pose) == Pose:\n text_pose = pose\n else:\n rospy.logerr(\"Pose is unsupported type '%s' in publishText()\", type(pose).__name__)\n return False\n\n # Convert input scale to a ROS Vector3 Msg\n if type(scale) == Vector3:\n text_scale = scale\n elif type(scale) == float:\n text_scale = Vector3(scale, scale, scale)\n else:\n rospy.logerr(\"Scale is unsupported type '%s' in publishText()\", type(scale).__name__)\n return False\n\n # Increment the ID number\n self.text_marker.id += 1\n\n # Get the default parameters\n text_marker = self.text_marker\n\n if lifetime == None:\n text_marker.lifetime = rospy.Duration(0.0) # 0 = Marker never expires\n else:\n text_marker.lifetime = rospy.Duration(lifetime) # in seconds\n\n # Set the timestamp\n text_marker.header.stamp = rospy.Time.now()\n\n # Set the pose\n text_marker.pose = text_pose\n\n # Set marker size\n text_marker.scale = text_scale\n\n # Set marker color\n text_marker.color = self.getColor(color)\n\n text_marker.text = text\n\n return self.publishMarker(text_marker)\n\n \n#------------------------------------------------------------------------------#\n\n\ndef pose_to_mat(pose):\n \"\"\"\n Convert a ROS Pose msg to a 4x4 matrix.\n\n @param pose (ROS geometry_msgs.msg.Pose)\n\n @return mat 4x4 matrix (numpy.matrix)\n \"\"\"\n\n quat = [pose.orientation.x, pose.orientation.y, pose.orientation.z, pose.orientation.w]\n pos = numpy.matrix([pose.position.x, pose.position.y, pose.position.z]).T\n mat = numpy.matrix(tf.transformations.quaternion_matrix(quat))\n mat[0:3, 3] = pos\n\n return mat\n\n\ndef mat_to_pose(mat):\n \"\"\"\n Convert a homogeneous transformation matrix to a ROS Pose msg.\n\n @param mat 4x4 homogenous transform (numpy.matrix or numpy.ndarray)\n\n @return pose (ROS geometry_msgs.msg.Pose)\n \"\"\"\n\n pose = Pose()\n pose.position.x = mat[0,3]\n pose.position.y = mat[1,3]\n pose.position.z = mat[2,3]\n\n quat = tf.transformations.quaternion_from_matrix(mat)\n pose.orientation.x = quat[0]\n pose.orientation.y = quat[1]\n pose.orientation.z = quat[2]\n pose.orientation.w = quat[3]\n\n return pose\n" ]

[ [ "numpy.matrix", "numpy.fabs" ] ]

lclc19/vertex-ai-samples

[ "1844df54a6fc3d7afff1110a6758afaf13181b19" ]

[ "community-content/tf_keras_text_classification_distributed_single_worker_gpus_with_gcloud_local_run_and_vertex_sdk/trainer/task.py" ]

[ "# Copyright 2021 Google LLC\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport argparse\nimport os\n\nimport tensorflow as tf\n\nfrom tensorflow.keras import layers, losses\nfrom tensorflow.keras.layers.experimental.preprocessing import TextVectorization\n\nimport distribution_utils\nimport utils\n\nVOCAB_SIZE = 10000\nMAX_SEQUENCE_LENGTH = 250\n\ndef parse_args():\n\n parser = argparse.ArgumentParser()\n\n # Using environment variables for Cloud Storage directories\n # see more details in https://cloud.google.com/vertex-ai/docs/training/code-requirements\n parser.add_argument(\n '--model-dir', default=os.getenv('AIP_MODEL_DIR'), type=str,\n help='a Cloud Storage URI of a directory intended for saving model artifacts')\n parser.add_argument(\n '--tensorboard-log-dir', default=os.getenv('AIP_TENSORBOARD_LOG_DIR'), type=str,\n help='a Cloud Storage URI of a directory intended for saving TensorBoard')\n parser.add_argument(\n '--checkpoint-dir', default=os.getenv('AIP_CHECKPOINT_DIR'), type=str,\n help='a Cloud Storage URI of a directory intended for saving checkpoints')\n\n parser.add_argument(\n '--num-gpus', default=0, type=int, help='number of gpus')\n parser.add_argument(\n '--epochs', default=25, type=int, help='number of training epochs')\n parser.add_argument(\n '--batch-size', default=16, type=int, help='mini-batch size')\n parser.add_argument(\n '--model-version', default=1, type=int, help='model version')\n\n parser.add_argument(\n '--local-mode', action='store_true', help='use local mode when running on your local machine')\n\n args = parser.parse_args()\n\n return args\n\ndef download_data(data_dir):\n \"\"\"Download data.\"\"\"\n\n if not os.path.exists(data_dir):\n os.makedirs(data_dir)\n\n data_url = \"https://storage.googleapis.com/download.tensorflow.org/data/stack_overflow_16k.tar.gz\"\n dataset = tf.keras.utils.get_file(\n fname=\"stack_overflow_16k.tar.gz\",\n origin=data_url,\n untar=True,\n cache_dir=data_dir,\n cache_subdir=\"\",\n )\n dataset_dir = os.path.join(os.path.dirname(dataset))\n\n return dataset_dir\n\n\ndef load_dataset(dataset_dir, batch_size, validation_split=0.2, seed=42):\n\n train_dir = os.path.join(dataset_dir, 'train')\n test_dir = os.path.join(dataset_dir, 'test')\n\n raw_train_ds = tf.keras.preprocessing.text_dataset_from_directory(\n train_dir,\n batch_size=batch_size,\n validation_split=validation_split,\n subset='training',\n seed=seed)\n\n raw_val_ds = tf.keras.preprocessing.text_dataset_from_directory(\n train_dir,\n batch_size=batch_size,\n validation_split=validation_split,\n subset='validation',\n seed=seed)\n\n raw_test_ds = tf.keras.preprocessing.text_dataset_from_directory(\n test_dir,\n batch_size=batch_size,\n )\n\n for text_batch, label_batch in raw_train_ds.take(1):\n for i in range(10):\n print(\"Question: \", text_batch.numpy()[i])\n print(\"Label:\", label_batch.numpy()[i])\n\n for i, label in enumerate(raw_train_ds.class_names):\n print(\"Label\", i, \"corresponds to\", label)\n\n return raw_train_ds, raw_val_ds, raw_test_ds\n\ndef build_model(num_classes, loss, optimizer, metrics):\n # vocab_size is VOCAB_SIZE + 1 since 0 is used additionally for padding.\n model = tf.keras.Sequential([\n layers.Embedding(VOCAB_SIZE + 1, 64, mask_zero=True),\n layers.Conv1D(64, 5, padding=\"valid\", activation=\"relu\", strides=2),\n layers.GlobalMaxPooling1D(),\n layers.Dense(num_classes)\n ])\n\n model.compile(\n loss=loss,\n optimizer=optimizer,\n metrics=metrics)\n\n return model\n\ndef train(model, train_dataset, validation_dataset, epochs, tensorboard_log_dir, checkpoint_dir):\n\n tensorboard_callback = tf.keras.callbacks.TensorBoard(\n log_dir=tensorboard_log_dir,\n update_freq=1\n )\n checkpoint_callback = tf.keras.callbacks.ModelCheckpoint(\n filepath=os.path.join(checkpoint_dir, 'cp-{epoch:04d}.ckpt'),\n verbose=1,\n save_weights_only=True,\n save_freq=\"epoch\",\n period=100\n )\n\n history = model.fit(\n train_dataset,\n epochs=epochs,\n validation_data=validation_dataset,\n callbacks=[tensorboard_callback, checkpoint_callback]\n )\n\n print('Training accuracy: {acc}, loss: {loss}'.format(\n acc=history.history['accuracy'][-1], loss=history.history['loss'][-1]))\n print('Validation accuracy: {acc}, loss: {loss}'.format(\n acc=history.history['val_accuracy'][-1], loss=history.history['val_loss'][-1]))\n\n return\n\ndef get_string_labels(predicted_scores_batch, class_names):\n predicted_labels = tf.argmax(predicted_scores_batch, axis=1)\n predicted_labels = tf.gather(class_names, predicted_labels)\n return predicted_labels\n\ndef predict(export_model, class_names, inputs):\n predicted_scores = export_model.predict(inputs)\n predicted_labels = get_string_labels(predicted_scores, class_names)\n return predicted_labels\n\ndef main():\n\n args = parse_args()\n\n local_data_dir = './tmp/data'\n\n local_model_dir = './tmp/model'\n local_checkpoint_dir = './tmp/checkpoints'\n local_tensorboard_log_dir = './tmp/logs'\n\n #TODO: update when gcsfuse ready\n gcsfuse_ready = False\n\n model_dir = args.model_dir or local_model_dir\n checkpoint_dir = (gcsfuse_ready and\n args.checkpoint_dir) or local_checkpoint_dir\n tensorboard_log_dir = args.tensorboard_log_dir or local_tensorboard_log_dir\n\n class_names = ['csharp', 'java', 'javascript', 'python']\n class_indices = dict(zip(class_names, range(len(class_names))))\n num_classes = len(class_names)\n print(f' class names: {class_names}')\n print(f' class indices: {class_indices}')\n print(f' num classes: {num_classes}')\n\n strategy = distribution_utils.get_distribution_mirrored_strategy(\n num_gpus=args.num_gpus)\n print('Number of devices: {}'.format(strategy.num_replicas_in_sync))\n\n global_batch_size = args.batch_size * strategy.num_replicas_in_sync\n print(f'Global batch size: {global_batch_size}')\n\n dataset_dir = download_data(local_data_dir)\n raw_train_ds, raw_val_ds, raw_test_ds = load_dataset(dataset_dir, global_batch_size)\n\n vectorize_layer = TextVectorization(\n max_tokens=VOCAB_SIZE,\n output_mode='int',\n output_sequence_length=MAX_SEQUENCE_LENGTH)\n\n train_text = raw_train_ds.map(lambda text, labels: text)\n vectorize_layer.adapt(train_text)\n print('The vectorize_layer is adapted')\n\n def vectorize_text(text, label):\n text = tf.expand_dims(text, -1)\n return vectorize_layer(text), label\n\n # Retrieve a batch (of 32 reviews and labels) from the dataset\n text_batch, label_batch = next(iter(raw_train_ds))\n first_question, first_label = text_batch[0], label_batch[0]\n print(\"Question\", first_question)\n print(\"Label\", first_label)\n print(\"Vectorized question:\", vectorize_text(first_question, first_label)[0])\n\n train_ds = raw_train_ds.map(vectorize_text)\n val_ds = raw_val_ds.map(vectorize_text)\n test_ds = raw_test_ds.map(vectorize_text)\n\n AUTOTUNE = tf.data.AUTOTUNE\n\n def configure_dataset(dataset):\n return dataset.cache().prefetch(buffer_size=AUTOTUNE)\n\n train_ds = configure_dataset(train_ds)\n val_ds = configure_dataset(val_ds)\n test_ds = configure_dataset(test_ds)\n\n print('Build model')\n loss = losses.SparseCategoricalCrossentropy(from_logits=True),\n optimizer = 'adam'\n metrics = ['accuracy']\n\n with strategy.scope():\n model = build_model(\n num_classes=num_classes,\n loss=loss,\n optimizer=optimizer,\n metrics=metrics,\n )\n\n train(\n model=model,\n train_dataset=train_ds,\n validation_dataset=val_ds,\n epochs=args.epochs,\n tensorboard_log_dir=tensorboard_log_dir,\n checkpoint_dir=checkpoint_dir\n )\n\n test_loss, test_accuracy = model.evaluate(test_ds)\n print(\"Int model accuracy: {:2.2%}\".format(test_accuracy))\n\n with strategy.scope():\n export_model = tf.keras.Sequential(\n [vectorize_layer, model,\n layers.Activation('softmax')])\n\n export_model.compile(\n loss=losses.SparseCategoricalCrossentropy(from_logits=False),\n optimizer='adam',\n metrics=['accuracy'])\n\n loss, accuracy = export_model.evaluate(raw_test_ds)\n print(\"Accuracy: {:2.2%}\".format(accuracy))\n\n model_path = os.path.join(model_dir, str(args.model_version))\n model.save(model_path)\n print(f'Model version {args.model_version} is saved to {model_dir}')\n\n print(f'Tensorboard logs are saved to: {tensorboard_log_dir}')\n\n print(f'Checkpoints are saved to: {checkpoint_dir}')\n utils.gcs_upload(\n dir=checkpoint_dir,\n local_dir=local_checkpoint_dir,\n gcs_dir=args.checkpoint_dir,\n gcsfuse_ready=gcsfuse_ready,\n local_mode=args.local_mode\n )\n\n return\n\nif __name__ == '__main__':\n main()" ]

[ [ "tensorflow.keras.preprocessing.text_dataset_from_directory", "tensorflow.keras.layers.Activation", "tensorflow.keras.layers.experimental.preprocessing.TextVectorization", "tensorflow.keras.losses.SparseCategoricalCrossentropy", "tensorflow.keras.layers.Embedding", "tensorflow.keras.layers.Conv1D", "tensorflow.keras.layers.GlobalMaxPooling1D", "tensorflow.keras.layers.Dense", "tensorflow.expand_dims", "tensorflow.gather", "tensorflow.keras.utils.get_file", "tensorflow.keras.callbacks.TensorBoard", "tensorflow.argmax" ] ]

hfisser/s2_trucks

[ "323e73edb82e314e6695e8cf8d89c2de22f54b04" ]

[ "detect_trucks/TruckDetector.py" ]

[ "####################################################\n# Author: Henrik Fisser, 2020\n####################################################\n\nfrom array_utils.plot import plot_img\n\nimport os, warnings\nimport pandas as pd\nimport numpy as np\nimport geopandas as gpd\nimport xarray as xr\nfrom shapely.geometry import box\nfrom scipy.stats import linregress, spearmanr\nfrom datetime import datetime\n\nfrom array_utils.math import normalized_ratio, rescale\nfrom array_utils.geocoding import lat_from_meta, lon_from_meta, metadata_to_bbox_epsg4326\nfrom osm_utils.utils import get_roads, rasterize_osm\nfrom utils.ProgressBar import ProgressBar\n\nwarnings.filterwarnings(\"ignore\")\n\ndir_ancillary = os.path.join(\"F:\" + os.sep + \"Masterarbeit\", \"DLR\", \"project\", \"1_truck_detection\", \"truth\")\nTHRESHOLDS = pd.read_csv(os.path.join(dir_ancillary, \"thresholds.csv\"), index_col=0)\nRGB_VECTORS = pd.read_csv(os.path.join(dir_ancillary, \"rgb_vector_clusters.csv\"), index_col=0)\n\n# assume reflectance rescaled to [0., 1.]\n# REFLECTANCE\nMIN_RED = THRESHOLDS[\"red_low\"][0]\nMAX_RED = THRESHOLDS[\"red_high\"][0]\n#MAX_RED_BOX = THRESHOLDS[\"box_mean_red_high\"][0]\nMIN_GREEN = THRESHOLDS[\"green_low\"][0]\nMAX_GREEN = THRESHOLDS[\"green_high\"][0]\n#MAX_GREEN_BOX = THRESHOLDS[\"box_mean_green_high\"][0]\nMIN_BLUE = THRESHOLDS[\"blue_low\"][0]\nMAX_BLUE = THRESHOLDS[\"blue_high\"][0]\n#MAX_BLUE_BOX = THRESHOLDS[\"box_mean_blue_high\"][0]\nMIN_RGB_STD = THRESHOLDS[\"min_std\"][0] / 3\n# VEGETATION\nMAX_NDVI = THRESHOLDS[\"ndvi_mean\"][0] + THRESHOLDS[\"ndvi_std\"][0] * 3\n# RATIOS\nMIN_BLUE_RED_RATIO = 0\nMIN_BLUE_GREEN_RATIO = 0\nMIN_GREEN_BLUE_RATIO = 0\nMIN_RED_BLUE_RATIO = 0\n# SPATIAL\nMEAN_MAX_DIST_GREEN = THRESHOLDS[\"mean_max_dist_green\"][0]\nMEAN_MAX_DIST_RED = THRESHOLDS[\"mean_max_dist_red\"][0]\nMAX_MAX_DIST_GREEN = THRESHOLDS[\"max_max_dist_green\"][0]\nMAX_MAX_DIST_RED = THRESHOLDS[\"max_max_dist_red\"][0]\nMAX_ANGLE_BR_BG = THRESHOLDS[\"mean_red_green_spatial_angle\"][0] + THRESHOLDS[\"std_red_green_spatial_angle\"][0] * 3\n# SPECTRAL ANGLE\n#MIN_R_SQUARED = THRESHOLDS[\"mean_rgb_rsquared\"][0] - THRESHOLDS[\"std_rgb_rsquared\"][0] * 3\nDEFAULT_MIN_CORRELATION = 0.5\nMAX_SLOPE = 10\nMIN_SLOPE = 0.05\n\n# Open Street Maps buffer\nOSM_BUFFER = 25\n\n# Sensing offset\nSECONDS_OFFSET_B02_B04 = 1.01 # seconds\nTRUCK_LENGTH = 18.75 # meters\n\nHOME = os.path.dirname(__file__)\n\n\nclass Detector:\n def __init__(self, min_r_squared=None, min_blue_green_ratio=None, min_blue_red_ratio=None):\n \"\"\"\n Detector class for detecting large moving vehicles on roads using Sentinel-2 data\n :param min_r_squared: float minimum correlation threshold\n :param min_blue_green_ratio: float minimum blue-green ratio for detection\n :param min_blue_red_ratio: float minimum blue-red ratio for detection\n \"\"\"\n self.min_r_squared = min_r_squared\n self.min_blue_green = min_blue_green_ratio\n self.min_blue_red = min_blue_red_ratio\n self.min_score = None\n self.band_stack_np = None\n self.lat, self.lon = None, None\n self.trucks_np = None\n self.crs = None\n\n def pre_process(self, band_dict, metadata, subset_box=None):\n \"\"\"\n rescales data to 0-1 and calculates lat, lon coordinates, masks to OSM roads\n :param band_dict: dict holding 3 arrays with shape (height, width), keys are B02, B03, B04, B08\n :param metadata: dict metadata from rasterio IO\n :param subset_box: dict with int ymin, ymax, xmin, xmax\n \"\"\"\n self.min_r_squared = DEFAULT_MIN_CORRELATION #if self.min_r_squared is None else self.min_r_squared\n if not isinstance(band_dict, dict):\n raise TypeError(\"'band_dict' must be a dictionary\")\n try:\n test = band_dict[\"B02\"], band_dict[\"B03\"], band_dict[\"B04\"], band_dict[\"B08\"]\n except KeyError:\n raise KeyError(\"'band_dict' must contain 'B02', 'B03', 'B04', 'B08'\")\n if not isinstance(metadata, dict):\n raise TypeError(\"'metadata' must be a dictionary\")\n self.crs = metadata[\"crs\"]\n try:\n self.lat, self.lon = metadata[\"lat\"], metadata[\"lon\"]\n except KeyError:\n try:\n self.lat, self.lon = lat_from_meta(metadata), lon_from_meta(metadata)\n except KeyError as e:\n raise e\n box_utm = [np.min(self.lat), np.max(self.lon), np.max(self.lat), np.min(self.lon)]\n box_epsg4326 = metadata_to_bbox_epsg4326(metadata)\n dir_ancil = os.path.join(HOME, \"AUXILIARY\")\n if not os.path.exists(dir_ancil):\n os.mkdir(dir_ancil)\n box_epsg4326 = list(np.flip(box_epsg4326))\n osm_mask = self.get_osm_mask(box_epsg4326, metadata[\"crs\"], band_dict[\"B02\"],\n {\"lat\": self.lat, \"lon\": self.lon},\n dir_ancil)\n band_stack_np = np.array([band_dict[\"B04\"], band_dict[\"B03\"], band_dict[\"B02\"], band_dict[\"B08\"]])\n low_rgb_mask = self.calc_low_quantile_mask(band_stack_np[0:3], [0.2]) # mask out lowest 20 % reflectances\n #high_rgb_mask = self.calc_high_quantile_mask(band_stack_np[0:3], [0.98]) # mask out highest 1 % reflectances\n band_stack_np[:, np.isnan(low_rgb_mask)] = np.nan\n #band_stack_np[:, np.isnan(high_rgb_mask)] = np.nan\n band_stack_np *= osm_mask\n try:\n band_stack_np = band_stack_np[:, subset_box[\"ymin\"]:subset_box[\"ymax\"], subset_box[\"xmin\"]:subset_box[\"xmax\"]]\n self.lat = self.lat[subset_box[\"ymin\"]:subset_box[\"ymax\"] + 1]\n self.lon = self.lon[subset_box[\"xmin\"]:subset_box[\"xmax\"] + 1]\n except TypeError: # subset_box is allowed to be None\n pass\n band_stack_np_rescaled = band_stack_np.copy()\n band_stack_np = None\n band_stack_np_rescaled[np.isnan(band_stack_np_rescaled)] = 0\n band_stack_np_rescaled = rescale(band_stack_np_rescaled, 0, 1)\n # band_stack_np_rescaled[:, band_stack_np_rescaled[0] > THRESHOLDS[\"red_high\"][0]] = np.nan\n # band_stack_np_rescaled[:, band_stack_np_rescaled[1] > THRESHOLDS[\"green_high\"][0]] = np.nan\n # band_stack_np_rescaled[:, band_stack_np_rescaled[2] > THRESHOLDS[\"blue_high\"][0]] = np.nan\n band_stack_np_rescaled[band_stack_np_rescaled == 0] = np.nan\n return band_stack_np_rescaled\n\n def detect_trucks(self, band_stack_np):\n \"\"\"\n Method for detecting large moving vehicles, calls ratio-based detection and object delineation\n :param band_stack_np: numpy ndarray containing the pre-processed Sentinel-2 reflectance bands\n :return: GeoDataframe containing the detected boxes\n \"\"\"\n t0 = datetime.now()\n if not isinstance(band_stack_np, np.ndarray):\n raise TypeError(\"'band_stack_np' must be of type numpy.ndarray\")\n self.band_stack_np = band_stack_np\n self._detect()\n detections = self._context_zoom() # zoom into context around potential detection\n print(\"Duration: %s minutes\" % ((datetime.now() - t0).total_seconds() / 60))\n return detections\n\n def _detect(self):\n \"\"\"\n Detect pixels of superior blue reflectance based on band ratios\n \"\"\"\n b02, b03, b04 = self.band_stack_np[2], self.band_stack_np[1], self.band_stack_np[0]\n min_quantile_blue, max_quantile_blue = np.nanquantile(b02, [0.5]), np.nanquantile(b02, [0.999])\n max_quantile_green, max_quantile_red = np.nanquantile(b03, [0.9]), np.nanquantile(b04, [0.9])\n bg_ratio, br_ratio = normalized_ratio(b02, b03), normalized_ratio(b02, b04)\n bg = np.int8(bg_ratio > np.nanmean(b02) - np.nanmean(b03))\n br = np.int8(br_ratio > np.nanmean(b02) - np.nanmean(b04))\n blue_min = np.int8(b02 > min_quantile_blue) # exclude low 50 % blue\n blue_max = np.int8(b02 < max_quantile_blue)\n green_max = np.int8(b03 < max_quantile_green)\n red_max = np.int8(b04 < max_quantile_red)\n mask = self.expose_anomalous_pixels(self.band_stack_np)\n self.band_stack_np = self.band_stack_np * mask\n self.band_stack_np[self.band_stack_np == 0] = np.nan\n # ratios B02-B03 (blue-green) and B02-B04 (blue-red)\n std_min = np.int8(np.nanstd(self.band_stack_np[0:3], 0) * 10 >= THRESHOLDS[\"q1_std_at_max_blue\"][0])\n # self.trucks_np = np.int8(bg * br * blue_min * blue_max * std_min * green_max * red_max)\n self.trucks_np = np.int8(bg * br * blue_min * green_max * red_max * std_min)\n bg_ratio, br_ratio, blue_min, blue_max, green_max, red_max, std_min = None, None, None, None, None, None, None\n\n def _context_zoom(self):\n \"\"\"\n Looks at the spatial context each detected pixel and calls method for delineating potential object\n :return: GeoDataframe containing the detected boxes\n \"\"\"\n valid = np.where(self.trucks_np == 1) # y, x indices\n boxes = [[], [], [], [], [], [], [], [], [], [], [], []]\n y_max, x_max = self.trucks_np.shape\n print(\"Context zoom\\n%s\" % (len(valid[0])))\n pb = ProgressBar(len(valid[0]), 50)\n for y, x, i in zip(valid[0], valid[1], range(len(valid[0]))):\n pb.update(i)\n if self.trucks_np[y, x] != 1: # may be the case because previously eliminated\n continue\n radius_low = int(MEAN_MAX_DIST_RED) + 2\n radius_up = radius_low + 1\n # subset around potential detection\n y_low, y_up = y - radius_low, y + radius_up\n y_low, y_up = 0 if y_low < 0 else y_low, y_max if y_up > y_max else y_up\n x_low, x_up = x - radius_low, x + radius_up\n x_low, x_up = 0 if x_low < 0 else x_low, x_max if x_up > x_max else x_up\n self.trucks_np = self.eliminate_multi_detections(self.trucks_np, y, x)\n sub_stack = self.band_stack_np[:, y_low:y_up, x_low:x_up].copy()\n if np.count_nonzero(~np.isnan(sub_stack)) == 0:\n continue\n t0 = datetime.now()\n box_test_result = self._box_test(sub_stack)\n t1 = datetime.now()\n # print(\"Total: %s\" % str((t1 - t0).total_seconds()))\n try:\n the_box = box_test_result[\"box\"]\n except KeyError:\n continue\n else:\n box_metrics = box_test_result[\"box_metrics\"]\n bounding_box = [the_box[\"xmin\"], the_box[\"ymin\"], the_box[\"xmax\"], the_box[\"ymax\"]]\n # get box in full array\n box_full_array = [x_low + bounding_box[0], y_low + bounding_box[1],\n x_low + bounding_box[2], y_low + bounding_box[3]]\n box_full_array[2] = self.lon.shape[0] - 1 if box_full_array[2] >= self.lon.shape[0] else box_full_array[2]\n box_full_array[3] = self.lat.shape[0] - 1 if box_full_array[3] >= self.lat.shape[0] else box_full_array[3]\n ymax, xmax = box_full_array[3] + 1, box_full_array[2] + 1\n ymax = self.lat.shape[0] - 1 if ymax >= self.lat.shape[0] else ymax # may happen\n xmax = self.lon.shape[0] - 1 if xmax >= self.lon.shape[0] else xmax\n bounding_box = box(self.lon[box_full_array[0]],\n self.lat[box_full_array[1]],\n self.lon[xmax],\n self.lat[ymax])\n direction_degree = box_metrics[\"direction\"]\n values = [bounding_box, box_metrics[\"spectral_angle\"], box_metrics[\"slope\"],\n self.direction_degree_to_description(direction_degree), direction_degree,\n box_test_result[\"quantile\"], box_test_result[\"speed\"], box_metrics[\"score\"],\n box_metrics[\"std\"], box_metrics[\"red_mean\"], box_metrics[\"green_mean\"], box_metrics[\"blue_mean\"]]\n for idx, value in enumerate(values):\n boxes[idx].append(value)\n detections = gpd.GeoDataFrame({\"rsquared\": boxes[1],\n \"slope\": boxes[2],\n \"direction_description\": boxes[3],\n \"direction_degree\": boxes[4],\n \"localization_quantile\": boxes[5],\n \"speed\": boxes[6],\n \"score\": boxes[7],\n \"std\": boxes[8],\n \"red_ratio\": boxes[9],\n \"green_ratio\": boxes[10],\n \"blue_ratio\": boxes[11]},\n geometry=boxes[0],\n crs=self.crs)\n print(\"\\nNumber of detections: %s\" % (len(detections)))\n return detections\n\n def _box_test(self, subset):\n \"\"\"\n looks at subset around detection and localizes object as box\n :param subset: numpy ndarray of shape (4, 9, 9) containing the reflectances of subset\n :return: dict with resulting detection box and its metrics\n \"\"\"\n t0 = datetime.now()\n subset_copy = subset.copy()\n subset[:, normalized_ratio(subset[3], subset[0]) > MAX_NDVI] = np.nan\n detection_y, detection_x = int(subset.shape[1] / 2), int(subset.shape[2] / 2) # index of detection (center)\n detection_yx = [detection_y, detection_x]\n if np.isnan(subset[0, detection_y, detection_x]): # NDVI too high. Mask here, saves time\n return {}\n detection_stack = subset[:, detection_y, detection_x].copy()\n subset[:, detection_y, detection_x] = detection_stack.copy()\n if np.count_nonzero(~np.isnan(subset[0])) < 3:\n return {}\n n_bands = subset.shape[0] - 1\n ratios = np.zeros((n_bands * 2 + 2, subset.shape[1], subset.shape[2]))\n ratio_counterparts = [[1, 2], [0, 2], [0, 1]]\n for i in range(n_bands):\n for j, k in enumerate(ratio_counterparts[i]):\n ratios[i + i + j] = normalized_ratio(subset[i], subset[k])\n ratios[6] = np.nanstd(subset[0:3], 0) * 10\n ratios[7] = np.nanstd(ratios, 0) * 10\n ratios[:, np.isnan(ratios[0])] = np.nan\n # localize potential box through high quantile\n q = np.float32([0.99])\n # print(\"Section 1 took: %s\" % str((datetime.now() - t0).total_seconds()))\n t0 = datetime.now()\n qantiles_dummy = np.float32([1, 1])\n quantiles_sum = qantiles_dummy.copy()\n while np.count_nonzero(quantiles_sum) < 6 and q[0] > 0.5:\n quantiles_sum = self.quantile_filter(ratios, q)\n if quantiles_sum is None:\n quantiles_sum = qantiles_dummy.copy()\n q -= 0.01\n q += 0.01\n # print(\"Section 2 took: %s\" % str((datetime.now() - t0).total_seconds()))\n t0 = datetime.now()\n try:\n s = all(quantiles_sum == qantiles_dummy)\n except TypeError: # then it's alright\n pass\n else:\n return {}\n try:\n quantiles_sum[quantiles_sum > 0] = 1\n except TypeError:\n return {}\n # quantiles_sum = self.eliminate_single_nonzeros(quantiles_sum)\n if np.count_nonzero(quantiles_sum > 0) < 3:\n return {}\n for j, k, t in zip([0, 2, 4], [1, 3, 5], [MAX_MAX_DIST_RED + 1, MAX_MAX_DIST_GREEN + 1, 2]):\n subset, ratios, quantiles_sum = self._eliminate_distant_pixels(subset, ratios, ratios[j] + ratios[k],\n quantiles_sum, detection_yx, t, q)\n # apply cluster exposing method twice in order to account for changes introduced by filter\n y_low, x_low, y_up, x_up = detection_y - 1, detection_x - 1, detection_y + 2, detection_x + 2\n quantiles_sum[y_low:y_up, x_low:x_up] = np.zeros((3, 3)) # temporary\n spatial_cluster = self._expose_cluster(quantiles_sum, subset[0:3], False)\n # if a cluster has high amount of values exclude corners, potentially divide large cluster\n boxes, boxes_metrics, scores, clusters = [], [], [], []\n # print(\"Section 3 took: %s\" % str((datetime.now() - t0).total_seconds()))\n t0 = datetime.now()\n for cluster in np.unique(spatial_cluster[spatial_cluster != 0]):\n spatial_cluster[detection_y, detection_x] = cluster # assign value of cluster to detection pixel\n ys, xs = np.where(spatial_cluster == cluster)\n try:\n a_box = [np.min(ys), np.min(xs), np.max(ys), np.max(xs)]\n except ValueError:\n continue\n box_arr = subset[0:3, a_box[0]:a_box[2]+1, a_box[1]:a_box[3]+1].copy()\n # if (np.nanmean(np.nanstd(box_arr, 0)) * 10) < MIN_RGB_STD * 0.5: # be tolerant here\n # continue\n cluster_sub = spatial_cluster[a_box[0]:a_box[2]+1, a_box[1]:a_box[3]+1].copy()\n cluster_sub[np.isnan(box_arr[0])] = 0\n ys, xs = np.where(spatial_cluster == cluster)\n if len(ys) < 2:\n continue\n ys, xs = self.eliminate_outlier_indices(ys, xs)\n a_box = [np.min(ys), np.min(xs), np.max(ys), np.max(xs)]\n box_arr = subset[0:3, a_box[0]:a_box[2]+1, a_box[1]:a_box[3]+1].copy()\n if np.count_nonzero(~np.isnan(box_arr)) / 3 / (box_arr.shape[1] * box_arr.shape[2]) < 0.3: # too few pixels\n continue\n box_ratios = ratios[:, a_box[0]:a_box[2]+1, a_box[1]:a_box[3]+1].copy()\n t0b = datetime.now()\n box_metrics = self._characterize_spatial_spectral(box_arr, box_ratios)\n # a_box = self._crop_box(a_box, ratios, box_metrics[\"direction\"], detection_yx)\n #print(\"Section 4b took: %s\" % str((datetime.now() - t0b).total_seconds()))\n # box_arr = subset[0:3, a_box[0]:a_box[2] + 1, a_box[1]:a_box[3] + 1].copy()\n if all([box_arr.shape[1] <= 2, box_arr.shape[2] <= 2]):\n continue\n box_metrics = self.calc_score(box_metrics, box_arr)\n if self._spatial_spectral_match(box_metrics):\n clusters.append(cluster)\n boxes.append(a_box)\n boxes_metrics.append(box_metrics)\n scores.append(box_metrics[\"score\"])\n # print(\"Section 4 took: %s\" % str((datetime.now() - t0).total_seconds()))\n t0 = datetime.now()\n scores = np.array(scores)\n try:\n max_score = np.max(scores)\n match = np.where(scores == max_score)[0][0]\n except ValueError:\n return {}\n box_metrics, selected_box = boxes_metrics[match], boxes[match]\n if np.std(selected_box) == 0:\n return {}\n if any(self.box_too_large(selected_box, MAX_MAX_DIST_RED)):\n selected_box = self._subset_by_ratios(ratios, selected_box) # subset box to high quantile ratios\n if any(self.box_too_large(selected_box, MAX_MAX_DIST_RED)):\n subset_dict = self._subset_by_boxes(subset, ratios, selected_box, [3, 4]) # try default sub boxes\n try:\n box_metrics = subset_dict[\"box_metrics\"]\n except KeyError:\n pass\n else:\n a_box = subset_dict[\"selected_box\"]\n box_arr = subset[0:3, a_box[0]:a_box[2] + 1, a_box[1]:a_box[3] + 1]\n box_metrics = self.calc_score(box_metrics, box_arr)\n if not self._spatial_spectral_match(box_metrics):\n return {}\n box_too_small = all([(selected_box[2] - selected_box[0] + 1) <= 2, (selected_box[3] - selected_box[1] + 1) <= 2])\n if box_too_small or box_metrics[\"score\"] < self.min_score:\n return {}\n the_box = {\"ymin\": selected_box[0], \"xmin\": selected_box[1],\n \"ymax\": selected_box[2], \"xmax\": selected_box[3]}\n # print(\"Section 5 took: %s\" % str((datetime.now() - t0).total_seconds()))\n return {\"box\": the_box,\n \"box_metrics\": box_metrics,\n \"quantile\": q[0],\n \"speed\": self.calc_speed(ratios[:, the_box[\"ymin\"]:the_box[\"ymax\"]+1, the_box[\"xmin\"]:the_box[\"xmax\"]+1])}\n\n def _characterize_spatial_spectral(self, sub_arr, sub_variables):\n \"\"\"\n takes a subset of reflectance stack and corresponding variables (ratios, std) and returns metrics of correlation\n and spatial relationships\n :param sub_arr: numpy ndarray of shape (3, y, x) containing the reflectance bands\n :param sub_variables: numpy ndarray of shape (7, y, x) containing ratios of reflectance bands, RGB std\n and ratios std\n :return: dict containing the box metrics\n \"\"\"\n return_dict = {}\n keys = [\"spectral_angle\", \"spatial_angle\", \"slope\", \"red_length\", \"green_length\", \"direction\",\n \"blue_mean\", \"green_mean\", \"red_mean\", \"red_ratio_max\", \"green_ratio_max\", \"blue_ratio_max\"]\n for key in keys:\n return_dict[key] = np.nan\n return_dict_copy = return_dict.copy()\n blue_ratios = np.nansum(sub_variables[4:6], 0) + sub_arr[2] * 10 # sum of blue ratios\n green_ratios = np.nansum(sub_variables[2:4], 0) + sub_arr[1] * 10 # sum of green ratios\n red_ratios = np.nansum(sub_variables[0:2], 0) + sub_arr[0] * 10 # sum of red ratios\n try:\n try:\n blue_y, blue_x = self.crop_2d_indices(np.where(blue_ratios == np.nanmax(blue_ratios)))\n except ValueError:\n return return_dict\n else:\n green_ratios[blue_y, blue_x] = np.nan # set to nan in order to avoid double target\n green_y, green_x = self.crop_2d_indices(np.where(green_ratios == np.nanmax(green_ratios)))\n red_ratios[blue_y, blue_x] = np.nan # avoid double target\n red_ratios[green_y, green_x] = np.nan # \"\"\n red_y, red_x = self.crop_2d_indices(np.where(red_ratios == np.nanmax(red_ratios)))\n except IndexError:\n return return_dict\n blue_indices = [blue_y, blue_x]\n blue_red_spatial_vector = self.calc_vector([red_y, red_x], blue_indices) # spatial vector blue to red\n blue_green_spatial_vector = self.calc_vector([green_y, green_x], blue_indices) # spatial vector blue to green\n return_dict = {\"red_length\": self.calc_vector_length(blue_red_spatial_vector),\n \"green_length\": self.calc_vector_length(blue_green_spatial_vector),\n \"spatial_angle\": self.calc_vector_angle_in_degrees(blue_red_spatial_vector,\n blue_green_spatial_vector)}\n if not self._spatial_spectral_match(return_dict): # check that in order to reduce run time\n return return_dict_copy # if spatial metrics do not satisfy thresholds return here alread\n given_vector = np.hstack([sub_variables[4:6, blue_y, blue_x], # stack of variables and target pixels\n sub_variables[2:4, green_y, green_x],\n sub_variables[0:2, red_y, red_x],\n sub_variables[6, blue_y, blue_x],\n sub_variables[6, green_y, green_x],\n sub_variables[6, red_y, red_x],\n sub_variables[7, blue_y, blue_x],\n sub_variables[7, green_y, green_x],\n sub_variables[7, red_y, red_x],\n sub_arr[2, blue_y, blue_x],\n sub_arr[2, green_y, green_x],\n sub_arr[2, red_y, red_x],\n sub_arr[1, green_y, green_x],\n sub_arr[1, blue_y, blue_x],\n sub_arr[1, red_y, red_x],\n sub_arr[0, red_y, red_x],\n sub_arr[0, blue_y, blue_x],\n sub_arr[0, green_y, green_x]])\n col_names, spectral_angles, slopes, spearman = [], [], [], []\n for i in range(7):\n col_names = col_names + [\"rgb_vector\" + str(i) + str(j) for j in [0, 1, 2]]\n # calculate spearmanr correlations between given variables and all reference variables\n for row in RGB_VECTORS.iterrows():\n r = row[1]\n ref_vector = np.array([r[col_name] for col_name in col_names])\n regression = linregress(given_vector, ref_vector)\n spearman.append(spearmanr(given_vector, ref_vector)[0])\n #spectral_angles.append(regression.rvalue)\n slopes.append(regression.slope)\n # use mean of all spearmanr correlation coefficients as indicator for agreement with reference dataset\n return_dict[\"spectral_angle\"] = np.nanmean(spearman) #np.nanquantile(spectral_angles, [0.75])[0] - np.nanstd(spectral_angles)\n return_dict[\"slope\"] = np.nanmean(slopes)\n return_dict[\"direction\"] = self.calc_vector_direction_in_degree(np.mean(np.vstack([blue_red_spatial_vector,\n blue_green_spatial_vector]),\n axis=0))\n return_dict[\"red_mean\"] = np.nanmean(sub_arr[0])\n return_dict[\"green_mean\"] = np.nanmean(sub_arr[1])\n return_dict[\"blue_mean\"] = np.nanmean(sub_arr[2])\n return_dict[\"red_ratio_max\"] = np.nanmax(np.nanmax(sub_variables[0:2]))\n return_dict[\"green_ratio_max\"] = np.nanmax(np.nanmax(sub_variables[2:4]))\n return_dict[\"blue_ratio_max\"] = np.nanmax(np.nanmax(sub_variables[4:6]))\n return return_dict\n\n def _subset_by_ratios(self, ratios, selected_box):\n original_box = selected_box.copy()\n box_ratios = ratios[:, selected_box[0]:selected_box[2]+1, selected_box[1]:selected_box[3]+1]\n q = np.float32([0.2])\n too_large_y, too_large_x = True, True\n while any([too_large_y, too_large_x]) and q[0] < 1:\n too_large_y, too_large_x = self.box_too_large(selected_box, MAX_MAX_DIST_RED)\n if any([too_large_y, too_large_x]):\n quantiles_sum = self.quantile_filter(box_ratios, q)\n if quantiles_sum is not None:\n ys, xs = np.where(quantiles_sum != 0)\n try:\n selected_box = [min(ys), min(xs), max(ys), max(xs)]\n except ValueError:\n q += 0.01\n continue\n q += 0.01\n if selected_box != original_box:\n selected_box[2] = original_box[0] + selected_box[2]\n selected_box[3] = original_box[1] + selected_box[3]\n selected_box[0] += original_box[0]\n selected_box[1] += original_box[1]\n return selected_box\n\n def _subset_by_boxes(self, subset, ratios, selected_box, window_sizes):\n box_arr = subset[0:3, selected_box[0]:selected_box[2] + 1, selected_box[1]:selected_box[3] + 1]\n box_ratios = ratios[:, selected_box[0]:selected_box[2] + 1, selected_box[1]:selected_box[3] + 1]\n boxes, boxes_metrics, boxes_rsquared, boxes_rgb_sums, boxes_spatial_angle = [], [], [], [], []\n for w in window_sizes:\n y_indices_low = np.arange(0, box_arr.shape[1] - w + 1, 1)\n x_indices_low = np.arange(0, box_arr.shape[2] - w + 1, 1)\n y_indices_up = [y + w for y in y_indices_low]\n x_indices_up = [x + w for x in x_indices_low]\n for y_low, y_up in zip(y_indices_low, y_indices_up):\n for x_low, x_up in zip(x_indices_low, x_indices_up):\n sub_box_arr = box_arr[:, y_low:y_up, x_low:x_up]\n sub_box_ratios = box_ratios[:, y_low:y_up, x_low:x_up]\n box_metrics = self._characterize_spatial_spectral(sub_box_arr, sub_box_ratios)\n if self._spatial_spectral_match(box_metrics):\n max_values = [np.nanmax(sub_box_arr[i]) for i in range(sub_box_arr.shape[0])]\n boxes.append([y_low, x_low, y_up - 1, x_up - 1]) # -1 due to indexing\n boxes_metrics.append(box_metrics)\n boxes_rsquared.append(box_metrics[\"spectral_angle\"])\n boxes_rgb_sums.append(np.sum(max_values))\n boxes_spatial_angle.append(box_metrics[\"spatial_angle\"])\n combined = np.array(boxes_rsquared) + np.array(boxes_rgb_sums) - np.array(boxes_spatial_angle)\n try:\n max_combined = np.max(combined)\n except ValueError:\n return {}\n try:\n match = np.where(combined == max_combined)[0][0]\n except IndexError:\n return {}\n new_box = boxes[match]\n selected_box[2] = selected_box[0] + new_box[2]\n selected_box[3] = selected_box[1] + new_box[3]\n selected_box[0] += new_box[0]\n selected_box[1] += new_box[1]\n return {\"box_metrics\": boxes_metrics[match], \"selected_box\": selected_box}\n\n def _eliminate_distant_pixels(self, sub_arr, ratios, band_ratios, quantiles_sum, center, threshold, quantile):\n try:\n ys, xs = np.where(band_ratios > np.nanquantile(band_ratios, quantile))\n except ValueError:\n return sub_arr\n else:\n for y, x in zip(ys, xs):\n if self.calc_vector_length(self.calc_vector(center, [y, x])) > threshold:\n sub_arr[:, y, x] = np.nan\n ratios[:, y, x] = np.nan\n quantiles_sum[y, x] = 0\n return sub_arr, ratios, quantiles_sum\n\n def _expose_cluster(self, target_arr, band_stack, exclude_corners=True):\n target_arr[np.isnan(target_arr)] = 0\n if np.count_nonzero(target_arr) == 0:\n return target_arr\n try:\n center = [int(target_arr.shape[0] / 2), int(target_arr.shape[1] / 2)]\n except IndexError:\n return target_arr\n ys, xs = np.where(target_arr != 0)\n yet_seen, cluster_value, clusters = [], 0, target_arr.copy()\n for y, x in zip(ys, xs):\n distance_center = self.calc_vector_length(self.calc_vector([y, x], center)) - 1\n rgb_slice = band_stack[0:3, y, x]\n max_idx = np.where(rgb_slice == np.nanmax(rgb_slice))[0][0]\n distance_wrong = [distance_center > t for t in [MAX_MAX_DIST_RED, MEAN_MAX_DIST_RED, MEAN_MAX_DIST_GREEN]]\n max_idx_wrong = [True, max_idx not in [0, 1], max_idx not in [0, 1, 2]]\n should_continue = False\n for condition_a, condition_b in zip(distance_wrong, max_idx_wrong):\n if condition_a and condition_b:\n clusters[y, x], should_continue = 0, True\n break\n if should_continue:\n continue\n if not [y, x] in yet_seen:\n cluster_value += 1\n clusters, yet_seen = self._search_adjacent_non_zero(clusters, [y, x], cluster_value, yet_seen,\n exclude_corners)\n return clusters\n\n def _crop_box(self, given_box, ratios, direction, detection_yx):\n max_size = MAX_MAX_DIST_RED * 2\n box_size = (given_box[2] - given_box[0] + 1) * (given_box[3] - given_box[1] + 1)\n direction_match = any(np.abs([x - direction for x in [0, 90, 180, 270]]) < 45)\n q = [0.5]\n while direction_match and box_size >= max_size and q[0] < 1:\n box_ratios = ratios[:, given_box[0]:given_box[2] + 1, given_box[1]:given_box[3] + 1]\n quantiles = self.quantile_filter(box_ratios, q)\n if quantiles is not None:\n try:\n # always retain value 1 at detection\n quantiles[np.abs(detection_yx[0] - given_box[0]), np.abs(detection_yx[1] - given_box[1])] = 1\n except IndexError:\n pass\n ys, xs = np.where(quantiles != 0)\n try:\n given_box[2] = int(given_box[0] + max(ys))\n given_box[3] = int(given_box[1] + max(xs))\n given_box[0] += min(ys)\n given_box[1] += min(xs)\n except ValueError:\n q[0] += 0.1\n continue\n else:\n box_size = (given_box[2] - given_box[0] + 1) * (given_box[3] - given_box[1] + 1)\n if box_size >= max_size:\n q[0] += 0.1\n return given_box\n\n def _search_adjacent_non_zero(self, arr, point, new_value, yet_seen, exclude_corners):\n \"\"\"\n looks for non zeros in 3x3 window around point in array and assigns a new value to these non-zeros\n :param arr: np array\n :param point: list of int y, x indices\n :param new_value: int value to assign\n :param yet_seen: list of lists, each list is a point with int y, x indices that has been seen before\n :param exclude_corners: bool, if True the corners of 3x3 window are excluded\n :return: tuple of np array and list\n \"\"\"\n arr_modified = arr.copy()\n original_value = arr_modified[point[0], point[1]].copy()\n arr_modified[point[0], point[1]] = 0\n ymin, ymax = point[0]-1, point[0]+2\n xmin, xmax = point[1]-1, point[1]+2\n ymin, xmin = 0 if ymin < 0 else ymin, 0 if xmin < 0 else xmin\n window_3x3 = arr_modified[ymin:ymax, xmin:xmax].copy()\n if exclude_corners:\n for corner_y, corner_x in zip([0, 0, 2, 2], [0, 2, 0, 2]):\n try:\n window_3x3[corner_y, corner_x] = 0\n except IndexError:\n continue\n ys, xs = np.where(window_3x3 != 0)\n for y_local, x_local in zip(ys, xs):\n y, x = ymin + y_local, xmin + x_local\n if [y, x] not in yet_seen:\n arr_modified[y, x] = new_value\n arr_modified, yet_seen = self._search_adjacent_non_zero(arr_modified, [y, x], new_value, yet_seen,\n exclude_corners)\n yet_seen.append([y, x])\n value = original_value if point in yet_seen else new_value\n if point not in yet_seen:\n yet_seen.append(point)\n arr_modified[point[0], point[1]] = value\n return arr_modified, yet_seen\n\n def calc_speed(self, ratios):\n resolution = 10 # meters\n blue_ratios = np.nansum(ratios[4:6], 0)\n red_ratios = np.nansum(ratios[0:2], 0)\n green_ratios = np.nansum(ratios[2:4], 0)\n try:\n max_blue, max_red, max_green = np.nanmax(blue_ratios), np.nanmax(red_ratios), np.nanmax(green_ratios)\n except IndexError:\n return 0\n diameter = (np.max(ratios.shape[1:3]) - (1.5 - max_blue)) * resolution\n kilometers_hour = (diameter * (3600 / SECONDS_OFFSET_B02_B04)) / 1000\n return kilometers_hour\n\n def _spatial_spectral_match(self, metrics_dict):\n is_match = True\n has_values = 3\n# try:\n # ratios_means = [metrics_dict[\"red_ratio_max\"], metrics_dict[\"green_ratio_max\"], metrics_dict[\"blue_ratio_max\"]]\n # except KeyError:\n # has_values -= 1\n # else:\n # ratios_high = np.max(ratios_means) > 0.2\n # ratios_high_all = all([mean_value > 0.05 for mean_value in ratios_means])\n # ratios_high_all = ratios_high_all or sum([mean_value > 0.25 for mean_value in ratios_means]) >= 2\n # ratios_high_two = sum([mean_value > 0.15 for mean_value in ratios_means]) > 1\n # is_match *= ratios_high * ratios_high_all * ratios_high_two\n # try:\n # is_match *= metrics_dict[\"std\"] >= MIN_RGB_STD\n # except KeyError:\n # has_values -= 1\n try:\n is_match *= metrics_dict[\"spectral_angle\"] >= self.min_r_squared\n except KeyError:\n has_values -= 1\n try:\n is_match *= metrics_dict[\"score\"] >= self.min_score\n except KeyError:\n has_values -= 1\n try:\n green_length = metrics_dict[\"green_length\"]\n red_length = metrics_dict[\"red_length\"]\n is_match *= green_length < red_length\n is_match *= red_length < (MAX_MAX_DIST_RED + 0.5)\n is_match *= green_length < (MAX_MAX_DIST_GREEN + 0.5)\n except KeyError:\n has_values -= 1\n # try:\n # is_match *= metrics_dict[\"slope\"] < MAX_SLOPE\n # is_match *= metrics_dict[\"slope\"] > MIN_SLOPE\n # except KeyError:\n # has_values -= 1\n # try:\n # is_match *= metrics_dict[\"spatial_angle\"] < MAX_ANGLE_BR_BG\n # except KeyError:\n # has_values -= 1\n if has_values == 0:\n return False\n else:\n return is_match\n\n @staticmethod\n def calc_score(metrics_dict, sub_arr):\n metrics_dict[\"std\"] = np.nanmean(np.nanstd(sub_arr, 0)) * 10\n reflectance_means_sum = (metrics_dict[\"red_mean\"] + metrics_dict[\"blue_mean\"] + metrics_dict[\n \"green_mean\"]) * 10\n ratio_means_sum = metrics_dict[\"red_ratio_max\"] + metrics_dict[\"green_ratio_max\"] \\\n + metrics_dict[\"blue_ratio_max\"]\n metrics_dict[\"score\"] = metrics_dict[\"spectral_angle\"] + metrics_dict[\"std\"] - np.abs(\n 1 - metrics_dict[\"slope\"]) \\\n + reflectance_means_sum + ratio_means_sum - metrics_dict[\"spatial_angle\"] / 100\n return metrics_dict\n\n @staticmethod\n def calc_primary_accuracy(detected_boxes, validation_boxes):\n out_keys = [\"validation_percentage\", \"detection_percentage\", \"validation_intersection_percentage\",\n \"detection_intersection_percentage\"]\n out_dict = {}\n lens = [len(detected_boxes) == 0, len(validation_boxes) == 0]\n if lens[0]:\n print(\"No entries in 'detected_boxes'\")\n if lens[1]:\n print(\"No entries in 'validation_boxes'\")\n if any(lens):\n for key in out_keys:\n out_dict[key] = np.nan\n return out_dict\n intersections = {\"validation\": [], \"detection\": []}\n intersection_areas = {\"validation\": [], \"detection\": []}\n keys = [\"validation\", \"detection\"]\n for boxes_a, boxes_b, key in zip([validation_boxes, detected_boxes], [detected_boxes, validation_boxes], keys):\n for detected_box in boxes_a.geometry:\n for i, validation_box in enumerate(boxes_b.geometry):\n if detected_box.intersects(validation_box):\n intersections[key].append(i)\n detected_gpd = gpd.GeoDataFrame({\"geometry\": [detected_box]}).set_geometry(\"geometry\")\n validation_gpd = gpd.GeoDataFrame({\"geometry\": [validation_box]}).set_geometry(\"geometry\")\n detected_gpd.crs = detected_boxes.crs\n validation_gpd.crs = detected_gpd.crs\n intersected = gpd.overlay(detected_gpd, validation_gpd, how=\"intersection\")\n intersection_areas[key].append(intersected.area[0] / detected_gpd.area[0] * 100)\n out_values = [(len(intersections[\"validation\"]) / len(validation_boxes)) * 100,\n (len(intersections[\"detection\"]) / len(detected_boxes)) * 100,\n np.nanmean(np.array(intersection_areas[\"validation\"])),\n np.nanmean(np.array(intersection_areas[\"detection\"]))]\n for key, value in zip(out_keys, out_values):\n out_dict[key] = value\n return out_dict\n\n @staticmethod\n def eliminate_single_nonzeros(arr):\n for y in range(arr.shape[0]):\n for x in range(arr.shape[1]):\n window_3x3 = arr[y-1:y+2, x-1:x+2]\n if np.count_nonzero(window_3x3[~np.isnan(window_3x3)]) < 2:\n arr[y, x] = 0\n return arr\n\n @staticmethod\n def eliminate_outlier_indices(ys, xs):\n dtype_ys, dtype_xs = ys.dtype, xs.dtype\n ys, xs = ys.astype(np.float32), xs.astype(np.float32)\n unique_ys, unique_xs = np.unique(ys), np.unique(xs)\n n = len(ys)\n n_unique_ys, n_unique_xs = len(unique_ys), len(unique_xs)\n amount_unique_ys, amount_unique_xs = np.zeros(n_unique_ys), np.zeros(n_unique_xs)\n for unique_idx, amount_unique, indices in zip([unique_ys, unique_xs],\n [amount_unique_ys, amount_unique_xs],\n [ys, xs]):\n for i, idx in enumerate(unique_idx):\n amount_unique[i] = len(np.where(indices == idx)[0]) / n * 100\n for amounts, uniques, indices in zip([amount_unique_ys, amount_unique_xs], [unique_ys, unique_xs], [ys, xs]):\n if (amounts > 50).any(): # there is a major y\n outlier_idxs = np.where(amounts < 15)\n if len(outlier_idxs[0]) > 0:\n for outlier_idx in outlier_idxs:\n real_idx = uniques[outlier_idx]\n to_nan = indices == real_idx\n ys[to_nan] = np.nan # eliminate y and x index\n xs[to_nan] = np.nan\n ys, xs = ys[~np.isnan(ys)], xs[~np.isnan(xs)]\n return ys.astype(dtype_ys), xs.astype(dtype_xs)\n\n @staticmethod\n def quantile_filter(arr, quantile_value):\n \"\"\"\n Targets values of specified quantile and eliminates isolated values\n :param arr: numpy ndarray of shape (3, height, width) -> RGB\n :param quantile_value: list with float quantile in range of 0 and 1\n :return: numpy 2d array of shape (height, width)\n \"\"\"\n quantiles = np.array([arr[i] >= np.nanquantile(arr[i], quantile_value) for i in range(arr.shape[0])],\n dtype=np.int8)\n # quantiles_initial_sum = quantiles.sum(0)\n # if np.count_nonzero(np.int8(quantiles_initial_sum > 0) * np.int8(quantiles_initial_sum < 3)) == 0:\n # return None\n shape = quantiles.shape\n s = shape[1]\n buffers = [2, 2, 1, 1, 2, 2, s, s, s, s]\n for i in range(quantiles.shape[0]):\n for y in range(shape[1]):\n for x in range(shape[2]):\n buffer = buffers[i]\n y_low, y_up = y - buffer, y + buffer + 1\n x_low, x_up = x - buffer, x + buffer + 1\n y_low = 0 if y_low < 0 else y_low\n x_low = 0 if x_low < 0 else x_low\n y_up, x_up = shape[1] if y_up > shape[1] else y_up, shape[2] if x_up > shape[2] else x_up\n y_low = y_low - 1 if y_up == (shape[1] + 1) else y_low\n x_low = x_low - 1 if x_up == (shape[2] + 1) else x_low\n y_up, x_up = y_up + 1 if y_low == 0 else y_up, x_up + 1 if x_low == 0 else x_up\n original_value = quantiles[i, y, x]\n if original_value == 0:\n continue\n quantiles_sub = quantiles[:, y_low:y_up, x_low:x_up].copy()\n quantiles_sub[i] = np.zeros_like(quantiles_sub[i]) # look only for matches in other bands\n sums = [np.nansum(quantiles_sub[j]) for j in range(quantiles_sub.shape[0])]\n quantiles[i, y, x] = 0 if np.count_nonzero(sums) < 2 else original_value\n return quantiles.sum(0)\n\n @staticmethod\n def box_too_large(the_box, max_size):\n size_y, size_x = (the_box[2] - the_box[0] + 1), (the_box[3] - the_box[1] + 1)\n too_large_y = size_y > max_size\n too_large_x = size_x > max_size\n return too_large_y, too_large_x\n\n # not really needed\n @staticmethod\n def calc_low_ratios_mask(ratios, min_values_ratios):\n ratio_mask = np.zeros_like(ratios[0:3], dtype=np.int8)\n only_false = np.zeros(3, dtype=np.bool)\n # reflectance and ratio filter\n for i in range(ratio_mask.shape[0]):\n idx = 2 * i\n ratio_mask[i] = np.int8((ratios[idx] + ratios[idx + 1]) > min_values_ratios[i])\n only_false[i] = np.count_nonzero(ratio_mask) == 0\n ratio_mask = ratio_mask.sum(0)\n ratio_mask[ratio_mask > 2] = 0\n ratio_mask[(2 >= ratio_mask) * (ratio_mask > 0)] = 1\n return ratio_mask, only_false\n\n @staticmethod\n def calc_low_quantile_mask(reflectances, q):\n low_quantile_red = np.int8(reflectances[0] > np.nanquantile(reflectances[0], q))\n low_quantile_green = np.int8(reflectances[1] > np.nanquantile(reflectances[1], q))\n low_quantile_blue = np.int8(reflectances[2] > np.nanquantile(reflectances[2], q))\n low_quantile_mask = np.float32(low_quantile_red + low_quantile_green + low_quantile_blue)\n low_quantile_mask[low_quantile_mask == 0] = np.nan\n low_quantile_mask[low_quantile_mask > 0] = 1\n return low_quantile_mask\n\n @staticmethod\n def calc_high_quantile_mask(reflectances, q):\n high_quantile_red = np.int8(reflectances[0] < np.nanquantile(reflectances[0], q))\n high_quantile_green = np.int8(reflectances[1] < np.nanquantile(reflectances[1], q))\n high_quantile_blue = np.int8(reflectances[2] < np.nanquantile(reflectances[2], q))\n high_quantile_mask = np.float32(high_quantile_red + high_quantile_green + high_quantile_blue)\n high_quantile_mask[high_quantile_mask == 0] = np.nan\n high_quantile_mask[high_quantile_mask > 0] = 1\n return high_quantile_mask\n\n @staticmethod\n def expose_anomalous_pixels(band_stack_np):\n w = 100\n y_bound, x_bound = band_stack_np.shape[1], band_stack_np.shape[2]\n roads = np.zeros((3, band_stack_np.shape[1], band_stack_np.shape[2]), dtype=np.float32)\n for y in range(int(np.round(y_bound / w))):\n for x in range(int(np.round(x_bound / w))):\n y_idx, x_idx = np.clip((y + 1) * w, 0, y_bound), np.clip((x + 1) * w, 0, x_bound)\n y_low, x_low = int(np.clip(y_idx - w, 0, 1e+30)), int(np.clip(x_idx - w, 0, 1e+30))\n y_up, x_up = np.clip(y_idx + w + 1, 0, y_bound), np.clip(x_idx + w + 1, 0, x_bound)\n y_size, x_size = (y_up - y_low), (x_up - x_low)\n n = y_size * x_size\n subset = band_stack_np[:, y_low:y_up, x_low:x_up]\n roads[0, y_low:y_up, x_low:x_up] = np.repeat(np.nanmedian(subset[0]), n).reshape(y_size, x_size)\n roads[1, y_low:y_up, x_low:x_up] = np.repeat(np.nanmedian(subset[1]), n).reshape(y_size, x_size)\n roads[2, y_low:y_up, x_low:x_up] = np.repeat(np.nanmedian(subset[2]), n).reshape(y_size, x_size)\n #max_diff = np.nanmax(band_stack_np[0:3] - np.nanmin(roads, 0), 0)\n #mask = np.int8(max_diff > np.nanquantile(max_diff, [0.6]))\n diff_red = band_stack_np[0] - (roads[0] / 2)\n diff_green = band_stack_np[1] - (roads[1] / 2)\n diff_blue = band_stack_np[2] - (roads[2] / 2)\n diff_stack = np.array([diff_red, diff_green, diff_blue])\n mask = np.zeros_like(diff_stack[0])\n for i in range(diff_stack.shape[0]):\n mask += np.int8(diff_stack[i] > np.nanquantile(diff_stack[i], [0.6]))\n mask[mask != 0] = 1\n mask = np.int8(mask)\n return mask\n\n @staticmethod\n def get_osm_mask(bbox, crs, reference_arr, lat_lon_dict, dir_out):\n osm_file = get_roads(bbox, [\"motorway\", \"trunk\", \"primary\"], OSM_BUFFER,\n dir_out, str(bbox).replace(\", \", \"_\")[1:-1] + \"_osm_roads\", str(crs),\n reference_arr)\n osm_vec = gpd.read_file(osm_file)\n ref_xr = xr.DataArray(data=reference_arr, coords=lat_lon_dict, dims=[\"lat\", \"lon\"])\n osm_raster = rasterize_osm(osm_vec, ref_xr).astype(np.float32)\n osm_raster[osm_raster != 0] = 1\n osm_raster[osm_raster == 0] = np.nan\n return osm_raster\n\n @staticmethod\n def crop_2d_indices(indices):\n \"\"\"\n :param indices: tuple of np int64 indices as returned by np.where\n :return: np int32 indices. Cropped if longer than 1\n \"\"\"\n return np.array([index_arr[0] for index_arr in indices]).astype(np.int32)\n\n @staticmethod\n def calc_vector_direction_in_degree(vector):\n # [1,1] -> 45°; [-1,1] -> 135°; [-1,-1] -> 225°; [1,-1] -> 315°\n y_offset = 90 if vector[0] > 0 else 0\n x_offset = 90 if vector[1] < 0 else 0\n offset = 180 if y_offset == 0 and x_offset == 90 else 0\n if vector[0] == 0:\n direction = 0.\n else:\n direction = np.degrees(np.arctan(np.abs(vector[1]) / np.abs(vector[0])))\n direction += offset + y_offset + x_offset\n return direction\n\n @staticmethod\n def direction_degree_to_description(direction_degree):\n step = 22.5\n bins = np.arange(0, 359, step, dtype=np.float32)\n descriptions = np.array([\"N\", \"NNE\", \"NE\", \"ENE\",\n \"E\", \"ESE\", \"SE\", \"SEE\",\n \"S\", \"SSW\", \"SW\", \"WSW\",\n \"W\", \"WNW\", \"NW\", \"NNW\"])\n i, b = 0, -1\n while b < direction_degree and i < len(bins):\n b = bins[i]\n i += 1\n return descriptions[i - 1]\n\n @staticmethod\n def calc_vector_angle_in_degrees(a, b):\n cos = np.dot(a, b) / np.linalg.norm(a) / np.linalg.norm(b)\n if np.abs(cos) >= 1:\n return 0\n else:\n return np.degrees(np.arccos(cos))\n\n @staticmethod\n def calc_vector(b, a):\n \"\"\"\n :param b: 1d np.float32 array or array-like\n :param a: 1d np.float32 array or array-like\n :return: 2d np.float32 array, a vector pointing to origin\n \"\"\"\n vector = []\n for i in range(len(b)):\n try:\n vector.append(np.float32(b[i] - a[i]))\n except IndexError:\n raise IndexError(\"origin and target must be of equal length\")\n return np.array(vector).astype(np.float32)\n\n @staticmethod\n def calc_vector_length(vector):\n \"\"\"\n :param vector: np array vector\n :return: np float32\n \"\"\"\n squared = np.float32([element ** 2 for element in vector])\n return np.sqrt(squared.sum()).astype(np.float32)\n\n @staticmethod\n def get_smallest_deviation(arr, value):\n dev = np.abs(arr - value)\n return int(np.where(dev == dev.min())[0][0])\n\n @staticmethod\n def eliminate_multi_detections(arr, y, x):\n y0 = y - 2 if (y - 2) >= 0 else y\n x0 = x - 2 if (x - 2) >= 0 else x\n y1 = y + 3 if (y + 3) <= arr.shape[0] else arr.shape[0]\n x1 = x + 3 if (x + 3) <= arr.shape[1] else arr.shape[1]\n arr[y0:y1, x0:x1] = np.zeros((y1 - y0, x1 - x0))\n arr[y, x] = 1 # detection of interest remains\n return arr\n" ]

[ [ "numpy.nanmax", "numpy.dot", "numpy.nanmedian", "numpy.round", "numpy.max", "numpy.zeros_like", "numpy.nanmean", "scipy.stats.spearmanr", "numpy.nanstd", "numpy.where", "numpy.hstack", "numpy.unique", "numpy.clip", "numpy.arange", "numpy.int8", "numpy.std", "numpy.nansum", "numpy.float32", "numpy.count_nonzero", "numpy.zeros", "numpy.min", "numpy.isnan", "numpy.arccos", "scipy.stats.linregress", "numpy.array", "numpy.flip", "numpy.sum", "numpy.abs", "numpy.linalg.norm", "numpy.nanquantile", "numpy.vstack" ] ]

adam-coogan/pyro

[ "6395b0f5f0b4744d3c822a39526027fb3fdb8b04" ]

[ "pyro/distributions/empirical.py" ]

[ "from __future__ import absolute_import, division, print_function\n\nimport math\nimport numbers\n\nimport torch\nfrom torch.distributions import constraints\n\nfrom pyro.distributions.torch import Categorical\nfrom pyro.distributions.torch_distribution import TorchDistribution\nfrom pyro.distributions.util import copy_docs_from, logsumexp\n\n\n@copy_docs_from(TorchDistribution)\nclass Empirical(TorchDistribution):\n r\"\"\"\n Empirical distribution associated with the sampled data.\n \"\"\"\n\n arg_constraints = {}\n support = constraints.real\n has_enumerate_support = True\n\n def __init__(self, validate_args=None):\n self._samples = None\n self._log_weights = None\n self._categorical = None\n self._samples_buffer = []\n self._weights_buffer = []\n super(TorchDistribution, self).__init__(batch_shape=torch.Size(), validate_args=validate_args)\n\n @staticmethod\n def _append_from_buffer(tensor, buffer):\n \"\"\"\n Append values from the buffer to the finalized tensor, along the\n leftmost dimension.\n\n :param torch.Tensor tensor: tensor containing existing values.\n :param list buffer: list of new values.\n :return: tensor with new values appended at the bottom.\n \"\"\"\n buffer_tensor = torch.stack(buffer, dim=0)\n return torch.cat([tensor, buffer_tensor], dim=0)\n\n def _finalize(self):\n \"\"\"\n Appends values collected in the samples/weights buffers to their\n corresponding tensors.\n \"\"\"\n if not self._samples_buffer:\n return\n self._samples = self._append_from_buffer(self._samples, self._samples_buffer)\n self._log_weights = self._append_from_buffer(self._log_weights, self._weights_buffer)\n self._categorical = Categorical(logits=self._log_weights)\n # Reset buffers.\n self._samples_buffer, self._weights_buffer = [], []\n\n @property\n def sample_size(self):\n \"\"\"\n Number of samples that constitute the empirical distribution.\n\n :return int: number of samples collected.\n \"\"\"\n self._finalize()\n if self._samples is None:\n return 0\n return self._samples.size(0)\n\n def add(self, value, weight=None, log_weight=None):\n \"\"\"\n Adds a new data point to the sample. The values in successive calls to\n ``add`` must have the same tensor shape and size. Optionally, an\n importance weight can be specified via ``log_weight`` or ``weight``\n (default value of `1` is used if not specified).\n\n :param torch.Tensor value: tensor to add to the sample.\n :param torch.Tensor weight: log weight (optional) corresponding\n to the sample.\n :param torch.Tensor log_weight: weight (optional) corresponding\n to the sample.\n \"\"\"\n if self._validate_args:\n if weight is not None and log_weight is not None:\n raise ValueError(\"Only one of ```weight`` or ``log_weight`` should be specified.\")\n\n weight_type = value.new_empty(1).float().type() if value.dtype in (torch.int32, torch.int64) \\\n else value.type()\n # Apply default weight of 1.0.\n if log_weight is None and weight is None:\n log_weight = torch.tensor(0.0).type(weight_type)\n elif weight is not None and log_weight is None:\n log_weight = math.log(weight)\n if isinstance(log_weight, numbers.Number):\n log_weight = torch.tensor(log_weight).type(weight_type)\n if self._validate_args and log_weight.dim() > 0:\n raise ValueError(\"``weight.dim() > 0``, but weight should be a scalar.\")\n\n # Seed the container tensors with the correct tensor types\n if self._samples is None:\n self._samples = value.new_tensor([])\n self._log_weights = log_weight.new_tensor([])\n # Append to the buffer list\n self._samples_buffer.append(value)\n self._weights_buffer.append(log_weight)\n\n def sample(self, sample_shape=torch.Size()):\n self._finalize()\n idxs = self._categorical.sample(sample_shape=sample_shape)\n return self._samples[idxs]\n\n def log_prob(self, value):\n \"\"\"\n Returns the log of the probability mass function evaluated at ``value``.\n Note that this currently only supports scoring values with empty\n ``sample_shape``, i.e. an arbitrary batched sample is not allowed.\n\n :param torch.Tensor value: scalar or tensor value to be scored.\n \"\"\"\n if self._validate_args:\n if value.shape != self.event_shape:\n raise ValueError(\"``value.shape`` must be {}\".format(self.event_shape))\n self._finalize()\n selection_mask = self._samples.eq(value).contiguous().view(self.sample_size, -1)\n # Return -Inf if value is outside the support.\n if not selection_mask.any():\n return self._log_weights.new_zeros(torch.Size()).log()\n idxs = torch.arange(self.sample_size)[selection_mask.min(dim=-1)[0]]\n log_probs = self._categorical.log_prob(idxs)\n return logsumexp(log_probs, dim=-1)\n\n def _weighted_mean(self, value, dim=0):\n weights = self._log_weights.reshape([-1] + (value.dim() - 1) * [1])\n max_weight = weights.max(dim=dim)[0]\n relative_probs = (weights - max_weight).exp()\n return (value * relative_probs).sum(dim=dim) / relative_probs.sum(dim=dim)\n\n @property\n def event_shape(self):\n self._finalize()\n if self._samples is None:\n return None\n return self._samples.shape[1:]\n\n @property\n def mean(self):\n self._finalize()\n if self._samples.dtype in (torch.int32, torch.int64):\n raise ValueError(\"Mean for discrete empirical distribution undefined. \" +\n \"Consider converting samples to ``torch.float32`` \" +\n \"or ``torch.float64``. If these are samples from a \" +\n \"`Categorical` distribution, consider converting to a \" +\n \"`OneHotCategorical` distribution.\")\n return self._weighted_mean(self._samples)\n\n @property\n def variance(self):\n self._finalize()\n if self._samples.dtype in (torch.int32, torch.int64):\n raise ValueError(\"Variance for discrete empirical distribution undefined. \" +\n \"Consider converting samples to ``torch.float32`` \" +\n \"or ``torch.float64``. If these are samples from a \" +\n \"`Categorical` distribution, consider converting to a \" +\n \"`OneHotCategorical` distribution.\")\n deviation_squared = torch.pow(self._samples - self.mean, 2)\n return self._weighted_mean(deviation_squared)\n\n def get_samples_and_weights(self):\n self._finalize()\n return self._samples, self._log_weights\n\n def enumerate_support(self, expand=True):\n # Empirical does not support batching, so expanding is a no-op.\n self._finalize()\n return self._samples\n" ]

[ [ "torch.Size", "torch.cat", "torch.tensor", "torch.arange", "torch.stack", "torch.pow" ] ]

maxrudolph1/robotarium_mpe

[ "025c182899c0092c95e1ed3c2a38117f257cbe25" ]

[ "sim_results/results/read_results.py" ]

[ "import numpy as np\nfrom matplotlib import pyplot as plt\nimport pandas as pd\nimport seaborn as sb\nimport matplotlib.patches as mpatches\nfrom scipy.stats import mannwhitneyu\nsb.set_theme(style=\"darkgrid\")\n\nbcfc_rew = []\nunif_rew = []\nmono_rew = []\nrand_rew = []\n\ntasks = ['navigation','coverage','transport']\nmeths = ['expert', 'assigned', 'loc_based', 'uniform', 'combined']\ndata_dict = {}\ndiff_dict = {}\nfor meth in meths:\n data_dict[meth] = {}\n for i,task in enumerate(tasks):\n if meth == 'combined':\n data_dict[meth][task] = np.sum(np.load('./'+meth+'/reward_' + 'combined' + '.npy')[i].squeeze(), axis=0)\n else:\n data_dict[meth][task] = np.sum(np.load('./'+meth+'/reward_' + task + '.npy').squeeze(), axis=0)\nother_meths = [ 'loc_based', 'uniform', 'combined']\nfor meth in other_meths:\n diff_dict[meth] = {}\n for i, task in enumerate(tasks):\n diff_dict[meth][task] = data_dict['assigned'][task] - data_dict[meth][task]\n\n\nruns = data_dict['assigned']['navigation'].shape[0]\ntask_list = []\nmeth_list = []\nval_list = []\ndiff_task_list = []\ndiff_meth_list = []\ndiff_val_list = []\nfor meth in meths:\n for task in tasks:\n for i in range(runs):\n task_list.append(task)\n meth_list.append(meth)\n val_list.append(data_dict[meth][task][i])\n\nfor meth in other_meths:\n for task in tasks:\n for i in range(runs):\n diff_task_list.append(task)\n diff_meth_list.append(meth)\n diff_val_list.append(diff_dict[meth][task][i])\n\n\ndiffs = np.array(diff_val_list)\n\nprint(np.sum(diffs >= 0) / len(diff_val_list))\n\ndf = pd.DataFrame({'task' : task_list, 'meth': meth_list, 'rew':val_list})\ndiff_df = pd.DataFrame({'task' : diff_task_list, 'meth': diff_meth_list, 'rew':diff_val_list})\n\n\nfor task in tasks:\n for meth in other_meths:\n U1, p = mannwhitneyu(data_dict[meth][task],data_dict['assigned'][task])\n nx, ny = data_dict[meth][task].shape[0], data_dict['assigned'][task].shape[0]\n\n\ncount = 0\nfig, axs = plt.subplots(1,3)\nfor i,task in enumerate(tasks):\n for j,meth in enumerate(['combined']):\n \n count += 1\n mask = data_dict['assigned'][task] > data_dict[meth][task]\n axs[i].plot(data_dict[meth][task][mask],data_dict['assigned'][task][mask], 'g.')\n axs[i].plot(data_dict[meth][task][np.logical_not(mask)],data_dict['assigned'][task][np.logical_not(mask)], 'r.')\n perf = str(np.sum(mask)/mask.shape[0])\n print(perf)\n yl = axs[i].get_ylim()\n xl = axs[i].get_xlim()\n lim = np.array(xl if xl[1] - xl[0] > yl[1] - yl[0] else yl)\n axs[i].set_xlim(lim[0], lim[1])\n axs[i].set_ylim(lim[0], lim[1])\n axs[i].set_title(perf)\n axs[i].plot(lim, lim, '-')\n axs[i].set_aspect('equal')\n\n\n## Plotting Violins\n'''\nplt.figure()\nfor op,task in enumerate(tasks):\n plt.subplot(1,3,op+1)\n cur_data = df.query(\"task == '\" + task + \"'\")\n violin_width = 1 if task == 'navigation' else 1\n ax = sb.violinplot(data=cur_data, \n x='meth', \n y='rew',\n linewidth=0,\n label='_nolegend_',\n width=violin_width)\n ax = sb.stripplot(data=cur_data,\n x='meth',\n y='rew',\n size=1.5)\n boxwidth= 0.075 if task == 'transport' else 0.075\n sb.boxplot(data=cur_data,\n x='meth',\n y='rew',\n width=boxwidth,\n fliersize=0) \n \n #patches = []\n print(len(meths))\n ax.set_xticklabels([''] * len(meths))\n ax.set_xlabel('')\n #patches = []\n patches = []\n # Collect colors of violin plots and make opaque\n for col in [ax.collections[l] for l in [0,2,4,6,8]]: #[0,2,4,6] for 4 different plots\n patches.append(col.get_facecolor())\n print(col.get_facecolor())\n col.set_alpha(.2)\n for col in [ax.collections[l] for l in [9,10,11,12,13]]:#,12,13]]: # [8,9,10,11] for 4 different plots\n col.set_alpha(.3)\n\n print('----------') \n\n patch0 = mpatches.Patch(color=patches[0], label='Expert')\n patch1 = mpatches.Patch(color=patches[1], label='BCFC (Full Pipeline)')\n patch2 = mpatches.Patch(color=patches[2], label='BCFC (Random Task Allocation)')\n patch3 = mpatches.Patch(color=patches[3], label='BCFC (Uniform Task Allocation)')\n patch4 = mpatches.Patch(color=patches[4], label='Monolithic') \n\n if task == 'transport':\n plt.legend(handles=[patch0, patch1, patch2, patch3, patch4])\n plt.ylabel('Cumulative Episodic Reward')\n else:\n plt.ylabel('')\n pass#ax.get_legend().remove()\n\n\n lab = [task in e.lower() for e in tasks]\n res = [i for i, val in enumerate(lab) if val]\n plt.title(tasks[res[0]])\n\n\n\n\nplt.figure()\nfor op,task in enumerate(tasks):\n plt.subplot(1,3,op+1)\n cur_data = diff_df.query(\"task == '\" + task + \"'\")\n violin_width = 1 if task == 'navigation' else 1\n ax = sb.violinplot(data=cur_data, \n x='meth', \n y='rew',\n linewidth=0,\n label='_nolegend_',\n width=violin_width)\n ax = sb.stripplot(data=cur_data,\n x='meth',\n y='rew',\n size=1.5)\n boxwidth= 0.075 if task == 'transport' else 0.075\n sb.boxplot(data=cur_data,\n x='meth',\n y='rew',\n width=boxwidth,\n fliersize=0) \n \n #patches = []\n print(len(meths))\n ax.set_xticklabels([''] * len(other_meths))\n ax.set_xlabel('')\n #patches = []\n patches = []\n # Collect colors of violin plots and make opaque\n for col in [ax.collections[l] for l in [0,2,4]]: #[0,2,4,6] for 4 different plots\n patches.append(col.get_facecolor())\n print(col.get_facecolor())\n col.set_alpha(.2)\n for col in [ax.collections[l] for l in [6,7,8]]:#,12,13]]: # [8,9,10,11] for 4 different plots\n col.set_alpha(.3)\n\n print('----------') \n\n\n patch0 = mpatches.Patch(color=patches[0], label='BCFC (Random Task Allocation)')\n patch1 = mpatches.Patch(color=patches[1], label='BCFC (Uniform Task Allocation)')\n patch2 = mpatches.Patch(color=patches[2], label='Monolithic') \n\n if task == 'transport':\n plt.legend(handles=[patch0, patch1, patch2])\n plt.ylabel('Cumulative Episodic Reward')\n else:\n plt.ylabel('')\n pass#ax.get_legend().remove()\n\n\n lab = [task in e.lower() for e in tasks]\n res = [i for i, val in enumerate(lab) if val]\n plt.title(tasks[res[0]])\n'''\nplt.show(block=False)\nplt.pause(0.001) # Pause for interval seconds.\ninput(\"hit[enter] to end.\")\nplt.close('all') \n\n" ]

[ [ "numpy.logical_not", "numpy.sum", "matplotlib.pyplot.subplots", "pandas.DataFrame", "scipy.stats.mannwhitneyu", "matplotlib.pyplot.close", "numpy.load", "numpy.array", "matplotlib.pyplot.show", "matplotlib.pyplot.pause" ] ]

lukassnoek/MVCA

[ "dd194140a5babb4605b9248d34508b9d9e4f799c" ]

[ "analyses/utils.py" ]

[ "import numpy as np\nfrom scipy.special import hyp2f1, gammaln\n\n\ndef get_r2(iv, dv, stack_intercept=True):\n \"\"\" Regress dv onto iv and return r-squared.\n \n Parameters\n ----------\n iv : numpy array\n Array of shape N (samples) x K (features)\n dv : numpy array\n Array of shape N (samples) x 1\n stack_intercept : bool\n Whether to stack an intercept (vector with ones of length N).\n \n Returns\n -------\n r2 : float\n R-squared model fit.\n \"\"\"\n \n if iv.ndim == 1:\n # Add axis if shape is (N,)\n iv = iv[:, np.newaxis]\n \n if stack_intercept:\n iv = np.hstack((np.ones((iv.shape[0], 1)), iv))\n \n beta = np.linalg.lstsq(iv, dv)[0]\n dv_hat = iv.dot(beta).squeeze()\n r2 = 1 - (((dv - dv_hat) ** 2).sum() / ((dv - dv.mean()) ** 2).sum())\n \n return r2\n\n\ndef vectorized_corr(arr, arr_2D):\n \"\"\" Computes the correlation between an array and each column\n in a 2D array (each column represents a variable) in a vectorized\n way. \n \n Parameters\n ----------\n arr : numpy array\n Array of shape (N,)\n arr_2D : numpy array\n Array of shape (N, P), with P indicating different variables that\n will be correlated with arr\n \n Returns\n -------\n corrs : numpy array\n Array of shape (P,) with all correlations between arr and columns in arr_2D\n \"\"\"\n \n if arr.ndim == 1:\n arr = arr[:, np.newaxis]\n \n arr_c, arr_2D_c = arr - arr.mean(), arr_2D - arr_2D.mean(axis=0)\n r_num = np.sum(arr_c * arr_2D_c, axis=0) \n r_den = np.sqrt(np.sum(arr_c ** 2, axis=0) * np.sum(arr_2D_c ** 2, axis=0))\n corrs = r_num / r_den\n return corrs\n\n\ndef vectorized_partial_corr(arr, c, arr_2D, stack_intercept=True):\n \"\"\" Computes the correlation between an array and each column\n in a 2D array (each column represents a variable) in a vectorized\n way. \n \n Parameters\n ----------\n arr : numpy array\n Array of shape (N,)\n c : numpy array\n Array of shape (N,) that should be partialled out of arr_2D and arr\n arr_2D : numpy array\n Array of shape (N, P), with P indicating different variables that\n will be correlated with arr\n \n Returns\n -------\n corrs : numpy array\n Array of shape (P,) with all correlations between arr and columns in arr_2D\n \"\"\"\n\n if arr.ndim == 1:\n arr = arr[:, np.newaxis]\n \n if c.ndim == 1:\n # Add axis if shape is (N,)\n c = c[:, np.newaxis]\n \n if stack_intercept:\n c = np.hstack((np.ones((c.shape[0], 1)), c))\n\n arr_resid = arr - c.dot(np.linalg.lstsq(c, arr, rcond=None)[0])\n arr_2d_resid = arr_2D - c.dot(np.linalg.lstsq(c, arr_2D, rcond=None)[0])\n \n return vectorized_corr(arr_resid, arr_2d_resid)\n\n\ndef vectorized_semipartial_corr(arr, c, arr_2D, which='2D', stack_intercept=True):\n \"\"\" Computes the semipartial correlation between an array and each column\n in a 2D array (each column represents a variable) in a vectorized\n way. \n \n Parameters\n ----------\n arr : numpy array\n Array of shape (N,)\n c : numpy array\n Array of shape (N,) that should be partialled out of arr_2D and arr\n arr_2D : numpy array\n Array of shape (N, P), with P indicating different variables that\n will be correlated with arr\n \n Returns\n -------\n corrs : numpy array\n Array of shape (P,) with all correlations between arr and columns in arr_2D\n \"\"\"\n\n if arr.ndim == 1:\n arr = arr[:, np.newaxis]\n \n if c.ndim == 1:\n # Add axis if shape is (N,)\n c = c[:, np.newaxis]\n \n if stack_intercept:\n c = np.hstack((np.ones((c.shape[0], 1)), c))\n\n if which == '2D':\n arr_2D_resid = arr_2D - c.dot(np.linalg.lstsq(c, arr_2D, rcond=None)[0])\n return vectorized_corr(arr, arr_2D_resid)\n else:\n arr_resid = arr - c.dot(np.linalg.lstsq(c, arr)[0])\n return vectorized_corr(arr_resid, arr_2D)\n\n\ndef rpdf(rho, n, rs):\n \"\"\" rho = population correlation coefficient. \"\"\"\n lnum = np.log(n-2) + gammaln(n-1) + np.log((1-rho**2)**(.5*(n-1))) + np.log((1-rs**2)**(.5*(n-4)))\n lden = np.log(np.sqrt(2*np.pi)) + gammaln(n-.5) + np.log((1-rho*rs)**(n-3/2))\n fac = lnum - lden\n hyp = hyp2f1(.5, .5, (2*n-1)/2, (rho*rs+1)/2)\n return np.exp(fac) * hyp\n" ]

[ [ "numpy.log", "numpy.sqrt", "numpy.ones", "numpy.linalg.lstsq", "scipy.special.hyp2f1", "scipy.special.gammaln", "numpy.exp", "numpy.sum" ] ]

rongqingpin/iOS_app_data

[ "c9beecfb3878f64568b1d9626412ba6b346934cd" ]

[ "app_data2.py" ]

[ "import pandas as pd\nimport csv\nimport json\nimport re\n\n# load the category IDs\nflc = '/Users/pinqingkan/Desktop/Codes/Project_iTunes/'\n#flc = '/Users/Melanie/Library/Mobile Documents/com~apple~CloudDocs/Desktop/Codes/Project_iTunes/'\nfname = flc + 'IDs/iosapp_categories.csv'\nX0 = pd.read_csv(fname)\n# remove repetitive ones: 'games', 'magazines & newspapers', 'stickers'\nX0 = X0.drop(labels = [7, 28, 67], axis = 0)\n\nNcatg, N = X0.shape\n\n# creat a list of desired data\napp_keys = ['trackId',\n 'artistId',\n 'artistViewUrl', 'sellerUrl',\n 'contentAdvisoryRating', 'trackContentRating', 'averageUserRating', 'averageUserRatingForCurrentVersion',\n 'userRatingCount', 'userRatingCountForCurrentVersion',\n 'currency', 'formattedPrice', 'price',\n 'currentVersionReleaseDate', 'releaseDate', 'version',\n 'genreIds', 'primaryGenreId',\n 'fileSizeBytes',\n 'screenshotUrls', 'ipadScreenshotUrls',\n 'supportedDevices']\nNdict = len(app_keys)\napp_keys2 = ['trackId', 'description', 'features']\nNfeat = len(app_keys2)\n\nurl0 = 'https://itunes.apple.com/lookup?id='\n\n# loop through the categories\nfor icat in range(31, 33):#range(33, Ncatg)\n icategory = X0.Category.iloc[icat]\n icatid = X0.ID.iloc[icat]\n # record the data one file per category\n if (icatid >= 7000) & (icatid < 8000): fname0 = 'games'\n elif (icatid >= 13000) & (icatid < 14000): fname0 = 'magazines-newspapers'\n elif icatid >= 16000: fname0 = 'stickers'\n else: fname0 = icategory\n\n print(icategory)\n\n # load the new links\n try:\n fname = flc + 'isoapp_links/iosapp_' + icategory + '_links_072017.txt'\n with open(fname, 'r') as file:\n links = file.readlines()\n\n napp = len(links)\n for iapp in range(napp):\n match = re.search('id([\\d]+)\\?mt', links[iapp])\n if match:\n iurl = url0 + match.group(1)\n # load data from website\n Y = pd.read_json(iurl)\n\n # initialize the data\n app_dict = dict.fromkeys(app_keys)\n app_feat = dict.fromkeys(app_keys2)\n\n if len(Y) > 0:\n Y = Y['results'][0]\n\n # format & record the data\n for ikey in app_keys:\n if ikey in Y.keys():\n if ikey in ['screenshotUrls', 'ipadScreenshotUrls',\n 'supportedDevices',\n 'artistViewUrl', 'sellerUrl',\n 'genreIds']:\n app_dict[ikey] = len(Y[ikey])\n elif ikey in ['version']:\n if len(Y[ikey].encode()) == len(Y[ikey]):\n app_dict[ikey] = Y[ikey]\n else:\n app_dict[ikey] = Y[ikey]\n else:\n app_dict[ikey] = 0\n\n # record the description info\n for ikey in app_keys2:\n if ikey in Y.keys():\n app_feat[ikey] = Y[ikey]\n else:\n app_feat[ikey] = 0\n\n # convert into dataframe\n y = pd.DataFrame(app_dict, index = [0])\n\n # record the app data\n fname = flc + 'iosapp_data/app_data_' + fname0 + '.csv'\n with open(fname, 'a') as file:\n csvwriter = csv.writer(file, delimiter = '\\t')\n csvwriter.writerow(y.iloc[0,:].values)\n\n # record the description\n fname = flc + 'iosapp_data/app_descp_' + fname0 + '.json'\n with open(fname, 'a') as file:\n json.dump(app_feat, file)\n file.write('\\n')\n\n except FileNotFoundError: continue" ]

[ [ "pandas.read_csv", "pandas.read_json", "pandas.DataFrame" ] ]

cjwang/pyEX

[ "1b5f40f80110afaa4809ea48fac067033c7bdf89" ]

[ "pyEX/stocks/batch.py" ]

[ "# -*- coding: utf-8 -*-\nimport itertools\nimport pandas as pd\nfrom multiprocessing.pool import ThreadPool\nfrom ..common import _TIMEFRAME_CHART, _getJson, _raiseIfNotStr, PyEXception, _strOrDate, _toDatetime, _BATCH_TYPES\nfrom .fundamentals import _dividendsToDF, _earningsToDF, _financialsToDF, _splitsToDF\nfrom .news import _newsToDF\nfrom .prices import chart, _bookToDF, _chartToDF\nfrom .profiles import _companyToDF, _peersToDF\nfrom .research import _statsToDF\n\n\n_MAPPING = {\n 'book': _bookToDF,\n 'chart': _chartToDF,\n 'company': _companyToDF,\n 'dividends': _dividendsToDF,\n 'earnings': _earningsToDF,\n 'financials': _financialsToDF,\n 'stats': _statsToDF,\n 'news': _newsToDF,\n 'peers': _peersToDF,\n 'splits': _splitsToDF\n}\n\n\ndef batch(symbols, fields=None, range_='1m', last=10, token='', version='', filter=''):\n '''Batch several data requests into one invocation\n\n https://iexcloud.io/docs/api/#batch-requests\n\n\n Args:\n symbols (list); List of tickers to request\n fields (list); List of fields to request\n range_ (string); Date range for chart\n last (int);\n token (string); Access token\n version (string); API version\n filter (string); filters: https://iexcloud.io/docs/api/#filter-results\n\n Returns:\n dict: results in json\n '''\n fields = fields or _BATCH_TYPES[:10] # limit 10\n\n if not isinstance(symbols, [].__class__):\n if not isinstance(symbols, str):\n raise PyEXception('batch expects string or list of strings for symbols argument')\n\n if isinstance(fields, str):\n fields = [fields]\n\n if range_ not in _TIMEFRAME_CHART:\n raise PyEXception('Range must be in %s' % str(_TIMEFRAME_CHART))\n\n if isinstance(symbols, str):\n route = 'stock/{}/batch?types={}&range={}&last={}'.format(symbols, ','.join(fields), range_, last)\n return _getJson(route, token, version, filter)\n\n if len(symbols) > 100:\n raise PyEXception('IEX will only handle up to 100 symbols at a time!')\n route = 'stock/market/batch?symbols={}&types={}&range={}&last={}'.format(','.join(symbols), ','.join(fields), range_, last)\n return _getJson(route, token, version, filter)\n\n\ndef batchDF(symbols, fields=None, range_='1m', last=10, token='', version='', filter=''):\n '''Batch several data requests into one invocation\n\n https://iexcloud.io/docs/api/#batch-requests\n\n\n Args:\n symbols (list); List of tickers to request\n fields (list); List of fields to request\n range_ (string); Date range for chart\n last (int);\n token (string); Access token\n version (string); API version\n filter (string); filters: https://iexcloud.io/docs/api/#filter-results\n\n Returns:\n DataFrame: results in json\n '''\n x = batch(symbols, fields, range_, last, token, version, filter)\n\n ret = {}\n\n if isinstance(symbols, str):\n for field in x.keys():\n ret[field] = _MAPPING.get(field, pd.io.json.json_normalize)(x[field])\n else:\n for symbol in x.keys():\n for field in x[symbol].keys():\n if field not in ret:\n ret[field] = pd.DataFrame()\n\n dat = x[symbol][field]\n dat = _MAPPING.get(field, pd.io.json.json_normalize)(dat)\n dat['symbol'] = symbol\n\n ret[field] = pd.concat([ret[field], dat], sort=True)\n return ret\n\n\ndef bulkBatch(symbols, fields=None, range_='1m', last=10, token='', version='', filter=''):\n '''Optimized batch to fetch as much as possible at once\n\n https://iexcloud.io/docs/api/#batch-requests\n\n\n Args:\n symbols (list); List of tickers to request\n fields (list); List of fields to request\n range_ (string); Date range for chart\n last (int);\n token (string); Access token\n version (string); API version\n filter (string); filters: https://iexcloud.io/docs/api/#filter-results\n\n Returns:\n dict: results in json\n '''\n fields = fields or _BATCH_TYPES\n args = []\n empty_data = []\n list_orig = empty_data.__class__\n\n if not isinstance(symbols, list_orig):\n raise PyEXception('Symbols must be of type list')\n\n for i in range(0, len(symbols), 99):\n args.append((symbols[i:i + 99], fields, range_, last, token, version, filter))\n\n pool = ThreadPool(20)\n rets = pool.starmap(batch, args)\n pool.close()\n\n ret = {}\n\n for i, d in enumerate(rets):\n symbols_subset = args[i][0]\n if len(d) != len(symbols_subset):\n empty_data.extend(list_orig(set(symbols_subset) - set(d.keys())))\n ret.update(d)\n\n for k in empty_data:\n if k not in ret:\n if isinstance(fields, str):\n ret[k] = {}\n else:\n ret[k] = {x: {} for x in fields}\n return ret\n\n\ndef bulkBatchDF(symbols, fields=None, range_='1m', last=10, token='', version='', filter=''):\n '''Optimized batch to fetch as much as possible at once\n\n https://iexcloud.io/docs/api/#batch-requests\n\n\n Args:\n symbols (list); List of tickers to request\n fields (list); List of fields to request\n range_ (string); Date range for chart\n last (int);\n token (string); Access token\n version (string); API version\n filter (string); filters: https://iexcloud.io/docs/api/#filter-results\n\n Returns:\n DataFrame: results in json\n '''\n dat = bulkBatch(symbols, fields, range_, last, token, version, filter)\n ret = {}\n for symbol in dat:\n for field in dat[symbol]:\n if field not in ret:\n ret[field] = pd.DataFrame()\n\n d = dat[symbol][field]\n d = _MAPPING[field](d)\n d['symbol'] = symbol\n ret[field] = pd.concat([ret[field], d], sort=True)\n\n return ret\n\n\ndef bulkMinuteBars(symbol, dates, token='', version='', filter=''):\n '''fetch many dates worth of minute-bars for a given symbol'''\n _raiseIfNotStr(symbol)\n dates = [_strOrDate(date) for date in dates]\n list_orig = dates.__class__\n\n args = []\n for date in dates:\n args.append((symbol, '1d', date, token, version, filter))\n\n pool = ThreadPool(20)\n rets = pool.starmap(chart, args)\n pool.close()\n\n return list_orig(itertools.chain(*rets))\n\n\ndef bulkMinuteBarsDF(symbol, dates, token='', version='', filter=''):\n '''fetch many dates worth of minute-bars for a given symbol'''\n data = bulkMinuteBars(symbol, dates, token, version, filter)\n df = pd.DataFrame(data)\n if df.empty:\n return df\n _toDatetime(df)\n df.set_index(['date', 'minute'], inplace=True)\n return df\n" ]

[ [ "pandas.concat", "pandas.DataFrame" ] ]

kfirsalo/New-Graph-ZSL

[ "76ccd15e65e915858dca9d9097ddf9252e4250d3", "76ccd15e65e915858dca9d9097ddf9252e4250d3" ]

[ "graph_ZSL_w_argmin.py", "images_graph_creator.py" ]

[ "import json\nimport multiprocessing\nfrom datetime import datetime\n\nfrom node2vec import Node2Vec\nimport pandas as pd\nimport numpy as np\nimport networkx as nx\nimport pickle\nimport os\nimport argparse\nfrom numpy import linalg as la\nfrom sklearn.metrics.pairwise import cosine_similarity\nfrom sklearn import model_selection as sk_ms\nfrom sklearn.metrics import confusion_matrix\nfrom sklearn.multiclass import OneVsRestClassifier\nfrom sklearn.linear_model import LogisticRegression\nimport random\nimport math\nimport matplotlib as mpl\nimport matplotlib.pyplot as plt\nfrom itertools import chain\nfrom utils import set_gpu\nfrom utlis_graph_zsl import hist_plot, plot_confusion_matrix, plots_2measures_vs_parameter, grid\nfrom IMDb_data_preparation_E2V import MoviesGraph\n\nrandom.seed(0)\nnp.random.seed(0)\n\nHEADER = ['movie_weights',\n 'labels_weights',\n 'embedding_type',\n 'embedding_dimension',\n 'norma_type',\n 'class_edges_threshold',\n 'seen_percentage',\n 'data_name',\n 'awa2_attributes_weight',\n 'acc',\n 'seen_acc',\n 'unseen_acc']\n\n\nclass GraphImporter:\n \"\"\"\n class that responsible to import or create the relevant graph\n \"\"\"\n def __init__(self, args):\n self.data_name = args.data_name\n self.graph_percentage = args.graph_percentage\n self.threshold = args.threshold\n self.args = args\n\n def import_imdb_multi_graph(self, weights):\n \"\"\"\n Make our_imdb multi graph using class\n :param weights:\n :return:\n \"\"\"\n weights_dict = {'movies_edges': weights[0], 'labels_edges': weights[1]}\n dict_paths = {'cast': 'data_set/IMDb title_principals.csv', 'genre': 'data_set/IMDb movies.csv'}\n imdb = MoviesGraph(dict_paths, self.args.graph_percentage)\n gnx = imdb.create_graph()\n labels = imdb.labels2int(gnx)\n knowledge_gnx, knowledge_data = imdb.create_knowledge_graph(labels, self.threshold)\n multi_gnx = imdb.weighted_multi_graph(gnx, knowledge_gnx, labels, weights_dict)\n return multi_gnx\n\n def import_imdb_weighted_graph(self, weights):\n weights_dict = {'movies_edges': weights[0], 'labels_edges': weights[1]}\n dict_paths = {'cast': 'data_set/IMDb title_principals.csv', 'genre': 'data_set/IMDb movies.csv'}\n imdb = MoviesGraph(dict_paths, self.args.graph_percentage)\n gnx = imdb.create_graph()\n labels = imdb.labels2int(gnx)\n knowledge_gnx, knowledge_data = imdb.create_knowledge_graph(labels, float(self.threshold))\n weighted_graph = imdb.weighted_graph(gnx, knowledge_gnx, labels, weights_dict)\n return weighted_graph\n\n def import_graph(self):\n graph = nx.MultiGraph()\n data_path = self.data_name + '.txt'\n path = os.path.join(self.data_name, data_path)\n with open(path, 'r') as f:\n for line in f:\n items = line.strip().split()\n att1 = str(items[0][0])\n att2 = str(items[1][0])\n graph.add_node(items[0], key=att1)\n graph.add_node(items[1], key=att2)\n sort_att = np.array([att1, att2])\n sort_att = sorted(sort_att)\n graph.add_edge(items[0], items[1], key=str(sort_att[0]) + str(sort_att[1]))\n return graph\n\n def import_awa2_graph(self, awa2_weights, specific_split, att_weight):\n from images_graph_creator import Awa2GraphCreator, ImagesEmbeddings\n weights_dict = {'classes_edges': awa2_weights[0], 'labels_edges': awa2_weights[1]}\n set_gpu(self.args.gpu)\n graph_preparation = ImagesEmbeddings(self.args)\n dict_name_class, dict_class_name = graph_preparation.dict_name_class, graph_preparation.dict_class_name\n seen_classes, unseen_classes = graph_preparation.seen_classes, graph_preparation.unseen_classes\n embeds_matrix, dict_image_embed, dict_image_class = graph_preparation.images_embed_calculator()\n dict_idx_image_class = {i: dict_name_class[dict_image_class[image]]\n for i, image in enumerate(list(dict_image_class.keys()))}\n awa2_graph_creator = Awa2GraphCreator(embeds_matrix, dict_image_embed, dict_name_class, dict_idx_image_class,\n self.args.graph_percentage, self.args)\n image_graph = awa2_graph_creator.create_image_graph()\n kg, dict_class_nodes_translation = awa2_graph_creator.imagenet_knowledge_graph()\n kg = awa2_graph_creator.attributed_graph(kg, att_weight)\n seen_classes = [dict_class_nodes_translation[c] for c in seen_classes]\n unseen_classes = [dict_class_nodes_translation[c] for c in unseen_classes]\n split = {'seen': seen_classes, 'unseen': unseen_classes}\n labels_graph = awa2_graph_creator.create_labels_graph(dict_class_nodes_translation)\n awa2_graph = awa2_graph_creator.weighted_graph(image_graph, kg, labels_graph, weights_dict)\n nx.write_gpickle(awa2_graph, 'awa2/train/awa2_graph')\n if specific_split:\n return awa2_graph, split\n else:\n split = None\n return awa2_graph, split\n\n\nclass EmbeddingCreator(object):\n def __init__(self, graph=None, dimension=None, args=None):\n self.data_name = args.data_name\n self.dim = dimension\n self.graph = graph\n\n def create_node2vec_embeddings(self):\n # path1 = os.path.join(self.data_name, 'Node2Vec_embedding.pickle')\n # path2 = os.path.join(self.data_name, 'Node2Vec_embedding.csv')\n # if os.path.exists(path1):\n # with open(path1, 'rb') as handle:\n # dict_embeddings = pickle.load(handle)\n # elif os.path.exists(path2):\n # embedding_df = pd.read_csv(path2)\n # dict_embeddings = embedding_df.to_dict(orient='list')\n # with open(path2, 'wb') as handle:\n # pickle.dump(dict_embeddings, handle, protocol=3)\n # else:\n # node2vec = Node2Vec(self.graph, dimensions=16, walk_length=30, num_walks=200, workers=1)\n # model = node2vec.fit()\n # nodes = list(self.graph.nodes())\n # dict_embeddings = {}\n # for i in range(len(nodes)):\n # dict_embeddings.update({nodes[i]: np.asarray(model.wv.get_vector(nodes[i]))})\n # with open(path1, 'wb') as handle:\n # pickle.dump(dict_embeddings, handle, protocol=3)\n node2vec = Node2Vec(self.graph, dimensions=self.dim, walk_length=80, num_walks=16, workers=2)\n model = node2vec.fit()\n nodes = list(self.graph.nodes())\n dict_embeddings = {}\n for i in range(len(nodes)):\n dict_embeddings.update({nodes[i]: np.asarray(model.wv.get_vector(str(nodes[i])))})\n return dict_embeddings\n\n def create_event2vec_embeddings(self):\n data_path = self.data_name + '_e2v_embeddings.txt'\n path = os.path.join(self.data_name, data_path)\n cond = 0\n dict_embeddings = {}\n with open(path, 'r') as f:\n for line in f:\n if cond == 1:\n items = line.strip().split()\n dict_embeddings[items[0]] = items[1:]\n cond = 1\n return dict_embeddings\n\n def create_ogre_embeddings(self, user_initial_nodes_choice=None):\n from StaticGraphEmbeddings.our_embeddings_methods.static_embeddings import StaticEmbeddings\n if user_initial_nodes_choice is not None:\n static_embeddings = StaticEmbeddings(self.data_name, self.graph, initial_size=100, initial_method=\"node2vec\", method=\"OGRE\", H=user_initial_nodes_choice,\n dim=self.dim, choose=\"degrees\", regu_val=0, weighted_reg=False, epsilon=0.1, file_tags=None)\n else:\n static_embeddings = StaticEmbeddings(self.data_name, self.graph, dim=self.dim)\n dict_embeddings = static_embeddings.dict_embedding\n return dict_embeddings\n\n\nclass EdgesPreparation:\n def __init__(self, graph, args, split=None):\n self.args = args\n # self.multi_graph = multi_graph\n self.split = split\n self.graph = graph\n self.label_edges = self.make_label_edges()\n self.unseen_edges, self.test_edges, self.dict_test_edges, self.dict_train_edges, self.dict_unseen_edges \\\n = self.train_test_unseen_split()\n\n def make_label_edges(self):\n \"\"\"\n Make a list with all the edge from type \"labels_edges\", i.e. edges between a movie and its class.\n :return: list with labels_edges\n \"\"\"\n data_path = self.args.data_name + '_true_edges.pickle'\n nodes = list(self.graph.nodes)\n label_edges = []\n for node in nodes:\n if str(node)[0] == 'c':\n info = self.graph._adj[node]\n neighs = list(info.keys())\n for neigh in neighs:\n if info[neigh]['key'] == 'labels_edges':\n label_edges.append([node, neigh])\n try:\n with open(os.path.join(self.args.data_name, data_path), 'wb') as handle:\n pickle.dump(label_edges, handle, protocol=3)\n except:\n pass\n return label_edges\n\n @staticmethod\n def label_edges_classes_ordered(edge_data):\n \"\"\"\n Make a dict of classes and their labels_edges they belong to. For every label_edge\n there is only one class it belongs to.\n :return: a dict of classes and their labels_edges\n \"\"\"\n dict_class_label_edge = {}\n for edge in edge_data:\n if edge[0][0] == 'c':\n label = edge[0]\n else:\n label = edge[1]\n if dict_class_label_edge.get(label) is not None:\n edges = dict_class_label_edge[label]\n edges.append(edge)\n dict_class_label_edge[label] = edges\n else:\n dict_class_label_edge.update({label: [edge]})\n return dict_class_label_edge\n\n def train_test_unseen_split(self): # unseen edges\n ratio = self.args.ratio[0]\n dict_true_edges = self.label_edges_classes_ordered(self.label_edges)\n classes = list(dict_true_edges.keys())\n for i, k in enumerate(sorted(dict_true_edges, key=lambda x: len(dict_true_edges[x]), reverse=True)):\n classes[i] = k\n seen_classes = classes[:int(self.args.seen_percentage * len(classes))]\n unseen_classes = classes[int(self.args.seen_percentage * len(classes)):]\n if self.split is not None:\n seen_classes = self.split['seen']\n unseen_classes = self.split['unseen']\n # unseen_classes.append(classes[0])\n unseen_edges, seen_edges, train_edges, test_edges = [], [], [], []\n for c in unseen_classes:\n # class_edges = list(self.graph.edges(c))\n # for edge in class_edges:\n # self.graph[edge[0]][edge[1]]['weight'] *= 10\n for edge in dict_true_edges[c]:\n unseen_edges.append(edge)\n for c in seen_classes:\n seen_edges_c = []\n for edge in dict_true_edges[c]:\n seen_edges.append(edge)\n seen_edges_c.append(edge)\n random.Random(4).shuffle(seen_edges_c)\n train_edges_c = seen_edges_c[:int(ratio * len(seen_edges_c))]\n test_edges_c = seen_edges_c[int(ratio * len(seen_edges_c)):]\n for edge in train_edges_c:\n train_edges.append(edge)\n if len(test_edges_c) > 0:\n for edge in test_edges_c:\n test_edges.append(edge)\n # unseen_edges = [dict_true_edges[c] for c in unseen_classes]\n # seen_edges = [dict_true_edges[c] for c in seen_classes]\n # random.Random(4).shuffle(seen_edges)\n # train_edges = seen_edges[:int(ratio * len(seen_edges))]\n # test_edges = seen_edges[int(ratio * len(seen_edges)):]\n dict_train_edges = self.label_edges_classes_ordered(train_edges)\n dict_test_edges = self.label_edges_classes_ordered(test_edges)\n dict_unseen_edges = self.label_edges_classes_ordered(unseen_edges)\n # for c in unseen_classes:\n # unseen_edges.append(dict_true_edges[c])\n return unseen_edges, test_edges, dict_train_edges, dict_test_edges, dict_unseen_edges\n\n def seen_graph(self):\n graph = self.graph\n for edge in self.unseen_edges:\n graph.remove_edge(edge[0], edge[1])\n for edge in self.test_edges:\n graph.remove_edge(edge[0], edge[1])\n return graph\n\n def ogre_initial_nodes(self, gnx):\n train_classes = list(self.dict_train_edges.keys())\n train_nodes = train_classes.copy()\n for c in train_classes:\n train_nodes.append(self.dict_train_edges[c][0][1])\n # try:\n # train_nodes.append(self.dict_train_edges[c][1][1])\n # except:\n # continue\n intial_graph = gnx.subgraph(train_nodes)\n return intial_graph\n\n\nclass Classifier:\n def __init__(self, dict_train_true, dict_test_true, dict_unseen_edges,\n dict_projections, embedding, args):\n self.args = args\n self.embedding = embedding\n self.dict_true_edges = dict_train_true\n self.dict_test_true = dict_test_true\n self.dict_unseen_edges = dict_unseen_edges\n self.norm = set(args.norm)\n self.dict_projections = dict_projections\n\n def edges_distance(self, edges):\n \"\"\"\n Calculate the distance of an edge. Take the vertices of the edge and calculate the distance between their\n embeddings.\n We use to calculate The distance with L1, l2, Cosine Similarity.\n :param edge: the edge we want to find its distance.\n :return: The distance\n \"\"\"\n embed_edges_0 = [self.dict_projections[edge[0]] for edge in edges]\n embed_edges_1 = [self.dict_projections[edge[1]] for edge in edges]\n if self.norm == set('L1 Norm'):\n norms = la.norm(np.subtract(embed_edges_0, embed_edges_1), 1, axis=1)\n elif self.norm == set('L2 Norm'):\n norms = la.norm(np.subtract(embed_edges_0, embed_edges_1), 2, axis=1)\n elif self.norm == set('cosine'):\n try:\n all_norms = cosine_similarity(embed_edges_0, embed_edges_1)\n norms = []\n for i in range(len(all_norms)):\n if np.abs(all_norms[i, i]) <= 1:\n norms.append(math.acos(all_norms[i, i]))\n elif all_norms[i, i] > 1:\n norms.append(math.acos(1))\n elif all_norms[i, i] < -1:\n norms.append(math.acos(-1))\n # norms = [math.acos(all_norms[i, i]) if np.abs(all_norms[i, i]) < 1 else math.acos(1) for i in range(len(all_norms))]\n except:\n print('a')\n else:\n raise ValueError(f\"Wrong name of norm, {self.norm}\")\n final_norms = np.array(norms).reshape(-1, 1)\n return final_norms\n\n def edge_distance(self, edge):\n \"\"\"\n Calculate the distance of an edge. Take the vertices of the edge and calculate the distance between their\n embeddings.\n We use to calculate The distance with L1, l2, Cosine Similarity.\n :param edge: the edge we want to find its distance.\n :return: The distance\n \"\"\"\n try:\n embd1 = np.array(self.dict_projections[edge[0]]).astype(float)\n embd2 = np.array(self.dict_projections[edge[1]]).astype(float)\n except:\n embd1 = np.ones(self.args.embedding_dimension).astype(float)\n embd2 = np.zeros(self.args.embedding_dimension).astype(float)\n pass\n if self.norm == set('L1 Norm'):\n norm = la.norm(np.subtract(embd1, embd2), 1)\n elif self.norm == set('L2 Norm'):\n norm = la.norm(np.subtract(embd1, embd2), 1)\n elif self.norm == set('cosine'):\n norm = math.acos(cosine_similarity(embd1.reshape(1, -1), embd2.reshape(1, -1))[0])\n else:\n raise ValueError(f\"Wrong name of norm, {self.norm}\")\n return norm\n\n def calculate_classifier_value(self, true_edges, false_edges):\n \"\"\"\n Create x and y for Logistic Regression Classifier.\n self.dict_projections: A dictionary of all nodes embeddings, where keys==nodes and values==embeddings\n :param true_edges: A list of true edges.\n :param false_edges: A list of false edges.\n :return: x_true/x_false - The feature matrix for logistic regression classifier, of true/false edge.\n The i'th row is the norm score calculated for each edge.\n y_true_edge/y_false_edge - The edges labels, [1,0] for true/ [0,1] for false.\n Also the edge of the label is concatenate to the label.\n \"\"\"\n x_true = self.edges_distance(true_edges)\n x_false = self.edges_distance(false_edges)\n # x_true, x_false = np.array(norms_true).reshape(-1, 1), np.array(norms_false).reshape(-1, 1)\n y_true_edge = np.column_stack((np.ones(shape=(len(true_edges), 1)),\n np.zeros(shape=(len(true_edges), 1)))).astype(int)\n y_false_edge = np.column_stack((np.zeros(shape=(len(false_edges), 1)),\n np.ones(shape=(len(false_edges), 1)))).astype(int)\n return x_true, x_false, y_true_edge, y_false_edge\n\n def calculate_by_single_norm(self, true_edges, false_edges):\n x_true, x_false = np.zeros(shape=(len(true_edges), 1)), np.zeros(shape=(len(false_edges), 1))\n y_true_edge, y_false_edge = np.zeros(shape=(len(true_edges), 4)).astype(int), \\\n np.zeros(shape=(len(false_edges), 4)).astype(int)\n for i, edge in enumerate(true_edges):\n norm = self.edge_distance(edge)\n x_true[i, 0] = norm\n # y_true_edge[i, 2] = edge[0]\n # y_true_edge[i, 3] = edge[1]\n y_true_edge[i, 0] = str(1)\n for i, edge in enumerate(false_edges):\n norm = self.edge_distance(edge)\n x_false[i, 0] = norm\n # y_false_edge[i, 2] = edge[0]\n # y_false_edge[i, 3] = edge[1]\n y_false_edge[i, 1] = str(1)\n return x_true, x_false, y_true_edge, y_false_edge\n\n @staticmethod\n def concat_data(x_true, x_false, y_true_edge, y_false_edge):\n \"\"\"\n split the data into rain and test for the true edges and the false one.\n :param ratio: determine the train size.\n :return: THe split data\n \"\"\"\n x_train, y_train = np.concatenate((x_true, x_false), axis=0), \\\n np.concatenate((y_true_edge, y_false_edge), axis=0)\n # y_train = np.array([y_train_edge.T[0].reshape(-1, 1), y_train_edge.T[1].reshape(-1, 1)]).T.reshape(-1,\n # 2).astype(\n # int)\n return x_train, y_train\n\n def train(self):\n \"\"\"\n Prepare the data for train, also train the classifier and make the test data divide by classes.\n :return: The classifier and dict_class_movie_test\n \"\"\"\n path2 = os.path.join(self.args.data_name, f'train/dict_{self.embedding}_{self.args.norm}.pkl')\n classes = list(self.dict_true_edges.keys())\n # for i, k in enumerate(sorted(self.dict_true_edges, key=lambda x: len(self.dict_true_edges[x]), reverse=True)):\n # classes[i] = k\n dict_class_movie_test = {}\n test_classes = list(self.dict_test_true.keys())\n unseen_classes = list(self.dict_unseen_edges.keys())\n for c in test_classes:\n dict_movie_edge = {}\n for edge in self.dict_test_true[c]:\n if edge[0][0] == 'c':\n movie = edge[1]\n else:\n movie = edge[0]\n dict_movie_edge[movie] = edge\n dict_class_movie_test[c] = dict_movie_edge.copy()\n for c in unseen_classes:\n dict_movie_edge = {}\n for edge in self.dict_unseen_edges[c]:\n if edge[0][0] == 'c':\n movie = edge[1]\n else:\n movie = edge[0]\n dict_movie_edge[movie] = edge\n dict_class_movie_test[c] = dict_movie_edge.copy()\n # if not os.path.exists(os.path.join('Graph-ZSL', self.args.data_name)):\n # os.makedirs(os.path.join('Graph-ZSL', self.args.data_name))\n with open(path2, 'wb') as fid:\n pickle.dump(dict_class_movie_test, fid)\n return dict_class_movie_test\n\n def evaluate(self, dict_class_movie_test):\n # evaluate\n classes = list(dict_class_movie_test.keys())\n pred_true = []\n pred = []\n # for i, k in enumerate(sorted(dict_class_movie_test, key=lambda x: len(dict_class_movie_test[x]), reverse=True)):\n # classes[i] = k\n num_classes = len(classes)\n dict_measures = {'acc': {}, 'precision': {}}\n dict_class_measures = {}\n for c in classes:\n class_movies = list(dict_class_movie_test[c].keys())\n count = 0\n for m in class_movies:\n edges = np.array([np.repeat(m, num_classes), classes]).T\n class_test = np.zeros(shape=(len(edges), 1))\n # if set(self.args.embedding) != set('OGRE'):\n class_test = self.edges_distance(edges)\n # else:\n # for i, edge in enumerate(edges):\n # norm = self.edge_distance(edge)\n # class_test[i, 0] = norm\n # _, probs = self.predict_edge_classification(classif2, class_test)\n # pred_index = np.argmax(probs.T[0])\n pred_index = np.argmax(class_test)\n prediction = edges[pred_index]\n real_edge = list(dict_class_movie_test[c][m])\n pred_true.append(c)\n if prediction[0][0] == 'c':\n pred.append(prediction[0])\n else:\n pred.append(prediction[1])\n if prediction[0] == real_edge[0]:\n if prediction[1] == real_edge[1]:\n count += 1\n elif prediction[1] == real_edge[0]:\n if prediction[0] == real_edge[1]:\n count += 1\n accuracy = count / len(class_movies)\n dict_measures['acc'] = accuracy\n dict_class_measures[c] = dict_measures.copy()\n with open(os.path.join(self.args.data_name, f'dict_class_measures_{self.embedding}_{self.args.norm}.pkl'),\n 'wb') as handle:\n pickle.dump(dict_class_measures, handle, protocol=3)\n # TODO dict class measures for every ratio\n return dict_class_measures, pred, pred_true\n\n def evaluate_for_hist(self, dict_class_movie_test):\n # evaluate\n classes = list(dict_class_movie_test.keys())\n hist_real_unseen_pred = np.zeros(len(classes))\n hist_real_unseen_first_unseen = np.zeros(len(classes))\n pred_true = []\n pred = []\n # for i, k in enumerate(sorted(dict_class_movie_test, key=lambda x: len(dict_class_movie_test[x]), reverse=True)):\n # classes[i] = k\n num_classes = len(classes)\n seen_flag = np.zeros(int(self.args.seen_percentage*len(classes)))\n unseen_flag = np.ones(len(classes)-int(self.args.seen_percentage*len(classes)))\n classes_flag = np.concatenate((seen_flag, unseen_flag))\n dict_measures = {'acc': {}, 'precision': {}}\n dict_class_measures = {}\n for i, c in enumerate(classes):\n class_movies = list(dict_class_movie_test[c].keys())\n count = 0\n for m in class_movies:\n edges = np.array([np.repeat(m, num_classes), classes]).T\n class_test = np.zeros(shape=(len(edges), 1))\n # if set(self.args.embedding) != set('OGRE'):\n class_test = self.edges_distance(edges)\n # else:\n # for j, edge in enumerate(edges):\n # norm = self.edge_distance(edge)\n # class_test[j, 0] = norm\n # _, probs = self.predict_edge_classification(classif2, class_test)\n # pred_index = np.argmax(probs.T[0])\n try:\n class_norm_test = np.column_stack((np.column_stack((class_test, classes)), classes_flag))\n except:\n print('a')\n sorted_class_norm = class_norm_test[np.argsort(class_norm_test[:, 0])]\n # if set(self.args.norm) == set('cosine'):\n # sorted_class_norm = np.flip(sorted_class_norm)\n # sort_classes = sorted_class_norm.T[0]\n # else:\n sort_classes = sorted_class_norm.T[1]\n sort_norm = sorted_class_norm.T[0].astype(float)\n sort_classes_flag = sorted_class_norm.T[2].astype(float)\n # class_test[::-1].sort(axis=0)\n prediction = np.array([m, sort_classes[0]])\n # prediction = edges[pred_index]\n real_edge = list(dict_class_movie_test[c][m])\n pred_true.append(c)\n if i > int(self.args.seen_percentage*len(classes)):\n place = np.where(sort_classes == c)[0][0]\n hist_real_unseen_pred[place] += 1\n place = np.where(sort_classes_flag == 1)[0][0]\n if self.args.unseen_weight_advantage*sort_norm[place] < sort_norm[0]:\n pred.append(sort_classes[place])\n else:\n pred.append(sort_classes[0])\n # pred.append(sort_classes[0])\n # if prediction[0][0] == 'c':\n # pred.append(prediction[0])\n # else:\n # pred.append(prediction[1])\n if prediction[0] == real_edge[0]:\n if prediction[1] == real_edge[1]:\n count += 1\n elif prediction[1] == real_edge[0]:\n if prediction[0] == real_edge[1]:\n count += 1\n accuracy = count / len(class_movies)\n dict_measures['acc'] = accuracy\n dict_class_measures[c] = dict_measures.copy()\n with open(os.path.join(self.args.data_name, f'dict_class_measures_{self.embedding}_{self.args.norm}.pkl'),\n 'wb') as handle:\n pickle.dump(dict_class_measures, handle, protocol=3)\n # TODO dict class measures for every ratio\n return dict_class_measures, pred, pred_true, hist_real_unseen_pred\n\n def hist_plot_for_unseen_dist_eval(self, distances):\n title = 'Histogram Of The Distance Between \\n Unseen Label Norm And Predicted Norm'\n x_label = f'Distance, limit:{len(distances)}'\n y_label = 'Count'\n hist_plot(distances, title, x_label, y_label)\n plt.savefig(f'{self.args.data_name}/plots/hist_distance_real_unseen-prediction_'\n f'{self.embedding}_{self.args.norm}_{int(100*self.args.seen_percentage)}_seen_percent')\n\n def confusion_matrix_maker(self, dict_class_measures, pred, pred_true):\n conf_matrix = confusion_matrix(pred_true, pred, labels=list(dict_class_measures.keys()))\n seen_true_count = 0\n seen_count = 0\n unseen_true_count = 0\n unseen_count = 0\n seen_number = int(self.args.seen_percentage * len(conf_matrix))\n classes = list(dict_class_measures.keys())\n seen_idx = []\n unseen_idx = []\n for i, c in enumerate(classes):\n if len(set([c]).intersection(set(self.dict_unseen_edges.keys()))) > 0:\n unseen_idx.append(i)\n else:\n seen_idx.append(i)\n for i in seen_idx:\n seen_true_count += conf_matrix[i][i]\n for j in range(len(classes)):\n seen_count += conf_matrix[i][j]\n for i in unseen_idx:\n unseen_true_count += conf_matrix[i][i]\n for j in range(len(conf_matrix)):\n unseen_count += conf_matrix[i][j]\n # for i in range(len(conf_matrix))[:seen_number]:\n # seen_true_count += conf_matrix[i][i]\n # for j in range(len(conf_matrix)):\n # seen_count += conf_matrix[i][j]\n # for i in range(len(conf_matrix))[seen_number:]:\n # unseen_true_count += conf_matrix[i][i]\n # for j in range(len(conf_matrix)):\n # unseen_count += conf_matrix[i][j]\n accuracy = (seen_true_count + unseen_true_count) / (seen_count + unseen_count)\n seen_accuracy = seen_true_count / seen_count\n unseen_accuracy = unseen_true_count / unseen_count\n print(f'accuracy all: {accuracy}')\n print(f'accuracy all seen: {seen_accuracy}')\n print(f'accuracy all unseen: {unseen_accuracy}')\n return accuracy, seen_accuracy, unseen_accuracy, conf_matrix\n\n def plot_confusion_matrix_all_classes(self, conf_matrix):\n plt.figure(0)\n title = f'Confusion Matrix, ZSL {self.args.data_name} \\n' \\\n f'{self.embedding} {self.args.norm} {int(100 * self.args.seen_percentage)} Percent Seen'\n x_title = f\"True Labels {int(100 * self.args.seen_percentage)}/{100 - int(100 * self.args.seen_percentage)}\" \\\n f\" (seen/unseen)\"\n y_title = f\"Predicted Labels\"\n plot_confusion_matrix(conf_matrix, title, x_title, y_title)\n plt.savefig(f'{self.args.data_name}/plots/confusion_matrix_{self.embedding}_{self.args.norm}'\n f'_{int(100 * self.args.seen_percentage)}_seen_percent')\nfrom dataclasses import dataclass\n@dataclass\nclass InventoryItem:\n \"\"\"Class for keeping track of an item in inventory.\"\"\"\n data_name: str\n threshold: float\n norm: str\n embedding: str\n false_per_true: str\n norm: str\n\n\ndef define_args(params):\n print(params)\n weights = np.array([params['weights_movie_movie'], params['weights_movie_class']]).astype(float)\n parser = argparse.ArgumentParser()\n parser.add_argument('--data_name', default=params['data_name']) # our_imdb, awa2\n parser.add_argument('--threshold', default=params['threshold'])\n parser.add_argument('--norm', default=params['norma_types']) # cosine / L2 Norm / L1 Norm\n parser.add_argument('--embedding', default=params['embedding_type']) # Node2Vec / Event2Vec / OGRE\n # embedding = params[2]\n parser.add_argument('--false_per_true', default=10)\n parser.add_argument('--ratio', default=[0.8])\n parser.add_argument('--seen_percentage', default=float(params['seen_percentage']))\n parser.add_argument('--embedding_dimension', default=int(params['embedding_dimensions']))\n parser.add_argument('--unseen_weight_advantage', default=0.9)\n parser.add_argument('--graph_percentage', default=1)\n if params['data_name'] == 'awa2':\n parser.add_argument('--awa2_attributes_weight', default=params['awa2_attributes_weight'])\n import torch\n cuda = torch.cuda.is_available()\n parser.add_argument('--cnn', default='materials/resnet50-base.pth')\n if cuda:\n parser.add_argument('--gpu', default='0')\n else:\n parser.add_argument('--gpu', default='-1')\n parser.add_argument('--consider-trains', action='store_false')\n\n parser.add_argument('--output', default=None)\n parser.add_argument('--images_threshold', default=0.10)\n # embedding_dimension = params[3].astype(int)\n args = parser.parse_args()\n return args, weights\n\n\ndef obj_func_grid(params, specific_split=True, split=None): # split False or True\n \"\"\"\n Main Function for link prediction task.\n :return:\n \"\"\"\n args, weights = define_args(params)\n np.random.seed(0)\n # ratio_arr = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]\n graph_maker = GraphImporter(args)\n # multi_graph = graph_maker.import_imdb_multi_graph(weights)\n if args.data_name == 'our_imdb':\n weighted_graph = graph_maker.import_imdb_weighted_graph(weights)\n elif args.data_name == 'awa2':\n awa2_att_weight = params['awa2_attributes_weight']\n weighted_graph, split = graph_maker.import_awa2_graph(weights, specific_split, awa2_att_weight)\n else:\n raise ValueError(f\"Wrong name of DataSet, {args.data_name}\")\n edges_preparation = EdgesPreparation(weighted_graph, args, split)\n # dict_true_edges = edges_preparation.label_edges_classes_ordered(edges_preparation.label_edges)\n # dict_false_edges = edges_preparation.make_false_label_edges(dict_true_edges)\n dict_train_true = edges_preparation.dict_train_edges\n dict_test_true = edges_preparation.dict_test_edges\n dict_unseen_edges = edges_preparation.dict_unseen_edges\n graph = edges_preparation.seen_graph()\n embeddings_maker = EmbeddingCreator(graph, args.embedding_dimension, args)\n if args.embedding == 'Node2Vec':\n dict_embeddings = embeddings_maker.create_node2vec_embeddings()\n elif args.embedding == 'Event2Vec':\n dict_embeddings = embeddings_maker.create_event2vec_embeddings()\n elif args.embedding == 'OGRE':\n initial_nodes = edges_preparation.ogre_initial_nodes(graph)\n dict_embeddings = embeddings_maker.create_ogre_embeddings(user_initial_nodes_choice=initial_nodes)\n else:\n raise ValueError(f\"Wrong name of embedding, {args.embedding}\")\n classifier = Classifier(dict_train_true, dict_test_true, dict_unseen_edges,\n dict_embeddings, args.embedding, args)\n dict_class_movie_test = classifier.train()\n dict_class_measures_node2vec, pred, pred_true, hist_real_unseen_pred = classifier.evaluate_for_hist(dict_class_movie_test)\n # classifier.hist_plot_for_unseen_dist_eval(hist_real_unseen_pred)\n accuracy, seen_accuracy, unseen_accuracy, conf_matrix = classifier.confusion_matrix_maker(\n dict_class_measures_node2vec, pred, pred_true)\n # classifier.plot_confusion_matrix_all_classes(conf_matrix)\n return accuracy, seen_accuracy, unseen_accuracy\n\n\ndef flatten_dict(d):\n def items():\n for key, value in d.items():\n if isinstance(value, dict):\n for subkey, subvalue in flatten_dict(value).items():\n yield key + \".\" + subkey, subvalue\n else:\n yield key, value\n return dict(items())\n\n\ndef config_to_str(config):\n config = flatten_dict(config)\n return [str(config.get(k, \"--\")) for k in HEADER]\n\n\ndef run_grid(grid_params, res_dir, now):\n grid_params = grid_params if type(grid_params) is dict else json.load(open(grid_params, \"rt\"))\n res_filename = os.path.join(res_dir, f\"{grid_params['data_name'][0]}_grid_{now}.csv\")\n out = open(res_filename, \"wt\")\n out.write(f\"{','.join(HEADER)}\\n\")\n for config in grid(grid_params):\n param = {p: config[i] for i, p in enumerate(list(grid_params.keys()))}\n acc, seen_acc, unseen_acc = obj_func_grid(param)\n table_row = config_to_str(param)\n table_row[HEADER.index('acc')] = str(acc)\n table_row[HEADER.index('seen_acc')] = str(seen_acc)\n table_row[HEADER.index('unseen_acc')] = str(unseen_acc)\n out.write(f\"{','.join(table_row)}\\n\")\n out.close()\n\n\ndef main():\n seen_accuracies, unseen_accuracies = [], []\n parameters = {\n \"data_name\": ['our_imdb'], # 'awa2', 'our_imdb'\n \"embedding_type\": [\"Node2Vec\"],\n \"embedding_dimensions\": [32, 64, 128, 256],\n # \"weights_movie_class\": [1],\n # \"weights_movie_movie\": [1],\n \"weights_movie_class\": np.logspace(-2, 3, 6),\n \"weights_movie_movie\": np.logspace(-2, 3, 6),\n \"norma_types\": ['cosine'],\n \"threshold\": [0.3, 0.6, 0.9],\n \"seen_percentage\": [0.8],\n # \"seen_percentage\": np.linspace(0.1, 0.9, 9)\n \"awa2_attributes_weight\": [100] # 100 is the best for now\n }\n num = 0\n for param in grid(parameters):\n dict_param = {p: param[i] for i, p in enumerate(list(parameters.keys()))}\n # param = np.array([w_m_m, w_m_c, e_type, dim, norma_type, threshold, per, data, w_att])\n print(f'iteration number {num}')\n num += 1\n acc, seen_acc, unseen_acc = obj_func_grid(dict_param)\n seen_accuracies.append(seen_acc*100)\n unseen_accuracies.append(unseen_acc*100)\n # print(\"all accuracy: \", acc)\n dict_measures = {\"unseen_accuracy\": unseen_accuracies, \"seen_accuracy\": seen_accuracies}\n plots_2measures_vs_parameter(dict_measures, parameters[\"seen_percentage\"], 'seen Percentage', 'our_imdb',\n 'Zero Shot Learning', \"Accuracy\", parameters[\"norma_types\"][0],\n parameters[\"embedding_type\"][0])\n\n\nif __name__ == '__main__':\n res_dir = \"C:\\\\Users\\\\kfirs\\\\lab\\\\Zero Shot Learning\\\\New-Graph-ZSL\\\\grid_results\"\n # now = datetime.now().strftime(\"%d%m%y_%H%M%S\")\n now = \"01_03_21\"\n parameters = {\n \"data_name\": ['our_imdb'], # 'awa2', 'our_imdb'\n \"embedding_type\": [\"Node2Vec\"],\n \"embedding_dimensions\": [32, 64, 128, 256],\n # \"weights_movie_class\": [1],\n # \"weights_movie_movie\": [1],\n \"weights_movie_class\": np.logspace(-2, 3, 6),\n \"weights_movie_movie\": np.logspace(-2, 3, 6),\n \"norma_types\": ['cosine'],\n \"threshold\": [0.3, 0.6, 0.9],\n \"seen_percentage\": [0.8],\n # \"seen_percentage\": np.linspace(0.1, 0.9, 9)\n \"awa2_attributes_weight\": [100] # 100 is the best for now\n }\n processes = []\n parameters_by_procesess = []\n for w_m_m in parameters[\"weights_movie_movie\"]:\n for w_m_c in parameters[\"weights_movie_class\"]:\n param_by_parameters = parameters.copy()\n param_by_parameters[\"weights_movie_movie\"] = [w_m_m]\n param_by_parameters[\"weights_movie_class\"] = [w_m_c]\n parameters_by_procesess.append(param_by_parameters)\n for i in range(len(parameters_by_procesess)):\n proc = multiprocessing.Process(target=run_grid, args=(parameters_by_procesess[i], res_dir, now, ))\n processes.append(proc)\n proc.start()\n for p in processes:\n p.join()\n\n", "import argparse\nimport json\nimport os.path as osp\nfrom sklearn.metrics import confusion_matrix\nfrom sklearn.neighbors import KDTree\nfrom sklearn.preprocessing import normalize\nimport matplotlib.pyplot as plt\nimport matplotlib as mpl\nimport numpy as np\nfrom itertools import chain\nimport networkx as nx\nimport random\n\nimport torch\nfrom torch.utils.data import DataLoader\n\nfrom models.resnet import make_resnet50_base\n\nimport sys\n\nsys.path.insert(1, \"./ZSL _DataSets\")\nfrom image_folder import ImageFolder\nfrom utils import set_gpu, pick_vectors\nfrom utlis_graph_zsl import get_classes, classes_split\n\n\nclass ImagesEmbeddings:\n def __init__(self, args, data_path, split_path, save_path):\n self.data_path = data_path\n self.split_path = split_path\n self.images_embed_path = osp.join(save_path, 'matrix_embeds.npy')\n self.dict_image_embed_path = osp.join(save_path, 'dict_image_embed.npy')\n self.dict_image_class_path = osp.join(save_path, 'dict_image_class.npy')\n self.classes_path = osp.join(save_path, 'classes_ordered.npy')\n self.args = args\n self.seen_classes, self.unseen_classes = self.classes()\n self.dict_name_class, self.dict_class_name = self.classes_names_translation()\n self.cnn = self.cnn_maker()\n\n def classes(self):\n seen_classes, unseen_classes = classes_split(self.args.dataset, self.data_path, self.split_path)\n return seen_classes, unseen_classes\n\n def classes_names_translation(self):\n awa2_split = json.load(open(self.split_path, 'r'))\n train_names = awa2_split['train_names']\n test_names = awa2_split['test_names']\n seen_classes, unseen_classes = self.classes()\n dict_name_class = {name: c for name, c in\n zip(chain(train_names, test_names), chain(seen_classes, unseen_classes))}\n dict_class_name = {c: name for name, c in\n zip(chain(train_names, test_names), chain(seen_classes, unseen_classes))}\n return dict_name_class, dict_class_name\n\n def cnn_maker(self):\n cnn = make_resnet50_base()\n cnn.load_state_dict(torch.load(self.args.cnn))\n if self.args.gpu == 0:\n cnn = cnn.cuda()\n cnn.eval()\n return cnn\n\n def one_class_images_embed(self, dataset, embed_matrix, count):\n loader = DataLoader(dataset=dataset, batch_size=32,\n shuffle=False, num_workers=2)\n c = 0\n for batch_id, batch in enumerate(loader, 1):\n data, label = batch\n if cuda:\n data = data.cuda()\n with torch.no_grad():\n embeds = self.cnn(data)\n embed_matrix[c:c + loader.batch_size, :] = embeds # (batch_size, d)\n count += loader.batch_size\n c += loader.batch_size\n return embed_matrix, count\n\n def images_embed_calculator(self):\n action = 'test'\n classes = np.array([])\n if osp.exists(self.images_embed_path) and True:\n embeds_matrix = np.load(self.images_embed_path, allow_pickle=True)\n dict_image_class = np.load(self.dict_image_class_path, allow_pickle=True).item()\n dict_image_embed = np.load(self.dict_image_embed_path, allow_pickle=True).item()\n else:\n count = 0\n for i, name in enumerate(\n chain(self.dict_class_name[self.unseen_classes], self.dict_class_name[self.seen_classes])):\n dataset = ImageFolder(osp.join(self.data_path, 'images'), [name], f'{action}')\n embed_matrix = torch.tensor(np.zeros((len(dataset), 2048)))\n classes = np.concatenate((classes, np.repeat(name, len(dataset))))\n embed_matrix, count = self.one_class_images_embed(dataset, embed_matrix, count)\n b = np.array(dataset.data).T[0]\n im = np.array([item.split('/')[-1].split('.')[0] for item in b])\n if i == 0:\n embeds_matrix = embed_matrix\n ims = im\n else:\n embeds_matrix = torch.cat((embeds_matrix, embed_matrix), 1)\n ims = np.concatenate((ims, im))\n dict_image_class = dict(zip(ims, classes))\n dict_image_embed = dict(zip(ims, embeds_matrix.numpy()))\n np.save(self.images_embed_path, embeds_matrix)\n np.save(self.dict_image_class_path, dict_image_class)\n np.save(self.dict_image_embed_path, dict_image_embed)\n return embeds_matrix, dict_image_embed, dict_image_class\n\n\nclass Awa2GraphCreator:\n def __init__(self, embed_matrix, dict_image_embed, dict_name_class, dict_idx_image_class, images_nodes_percentage,\n args):\n self.image_graph_path = 'save_data_graph/awa2/image_graph.gpickle'\n self.pre_knowledge_graph_path = 'materials/imagenet-induced-graph.json'\n self.knowledge_graph_path = 'save_data_graph/awa2/knowledge_graph.gpickle'\n self.dict_wnids_class_translation = dict_name_class\n self.embeddings = normalize(embed_matrix, norm='l2', axis=0)\n self.dict_image_embed = dict_image_embed\n self.images = list(dict_image_embed.keys())\n self.dict_idx_image_class = dict_idx_image_class\n self.images_nodes_percentage = images_nodes_percentage\n self.args = args\n\n def index_embed_transform(self):\n dict_index_embed = {i: item for i, item in enumerate(self.images)}\n dict_embed_index = {item: i for i, item in enumerate(self.images)}\n return dict_index_embed, dict_embed_index\n\n def create_image_graph(self):\n if osp.exists(self.image_graph_path) and True:\n image_gnx = nx.read_gpickle(self.image_graph_path)\n else:\n image_gnx = nx.Graph()\n kdt = KDTree(self.embeddings, leaf_size=40)\n # image_graph.add_nodes_from(np.arange(len(self.embeddings)))\n count = 0\n for i in range(len(self.embeddings)):\n neighbors, distances = kdt.query_radius(self.embeddings[i:i + 1], r=self.args.images_threshold,\n return_distance=True)\n if len(neighbors[0]) == 1:\n distances, neighbors = kdt.query(self.embeddings[i:i + 1], k=2,\n return_distance=True)\n neighbors, distances = neighbors[0], distances[0]\n loop_ind = np.where(distances == 0)\n if len(loop_ind[0]) > 1:\n loop_ind = np.where(neighbors == i)\n neighbors = np.delete(neighbors, loop_ind)\n distances = np.delete(distances, loop_ind)\n # make distance into weights and fix zero distances\n edges_weights = [1 / dist if dist > 0 else 1000 for dist in distances]\n len_neigh = len(neighbors)\n count += len_neigh\n mean = count / (i + 1)\n if i % 1000 == 0:\n print('Progress:', i, '/', len(self.embeddings), '; Current Mean:', mean) # 37273\n weight_edges = list(zip(np.repeat(i, len(neighbors)).astype(str), neighbors.astype(str), edges_weights))\n image_gnx.add_weighted_edges_from(weight_edges)\n nx.write_gpickle(image_gnx, self.image_graph_path)\n return image_gnx\n\n def imagenet_knowledge_graph(self):\n graph = json.load(open(self.pre_knowledge_graph_path, 'r'))\n edges = graph['edges']\n nodes = graph['wnids']\n # dict_nodes_translation = {i: node for i, node in enumerate(nodes)}\n dict_class_nodes_translation = {node: 'c' + str(i) for i, node in enumerate(nodes)}\n dict_nodes_class_translation = {'c' + str(i): node for i, node in enumerate(nodes)}\n dict_class_nodes_translation = {**dict_class_nodes_translation, **dict_nodes_class_translation}\n # edges = [(dict_nodes_translation[x[0]],\n # dict_nodes_translation[x[1]]) for x in edges]\n edges = [('c' + str(x[0]), 'c' + str(x[1])) for x in edges]\n kg_imagenet = nx.Graph()\n kg_imagenet.add_edges_from(edges)\n return kg_imagenet, dict_class_nodes_translation\n\n def attributed_graph(self, kg_imagenet, att_weight):\n graph = json.load(open(self.pre_knowledge_graph_path, 'r'))\n nodes = graph['wnids']\n all_attributes = graph['vectors']\n dict_class_nodes = {node: i for i, node in enumerate(nodes)}\n dict_nodes_class = {i: node for i, node in enumerate(nodes)}\n dict_class_nodes_translation = {**dict_class_nodes, **dict_nodes_class}\n awa2_split = json.load(open('materials/awa2-split.json', 'r'))\n seen_classes = awa2_split['train']\n unseen_classes = awa2_split['test']\n s_u_classes = seen_classes + unseen_classes\n s_u_idx = [dict_class_nodes_translation[c] for c in s_u_classes]\n kd_idx_to_class_idx = {i: dict_class_nodes_translation[c] for i, c in enumerate(s_u_idx)}\n attributes = np.array([all_attributes[idx] for idx in s_u_idx])\n attributes = normalize(attributes, norm='l2', axis=1)\n kdt = KDTree(attributes, leaf_size=10)\n # image_graph.add_nodes_from(np.arange(len(self.embeddings)))\n count = 0\n for i in range(len(attributes)):\n neighbors, distances = kdt.query_radius(attributes[i:i + 1], r=1.15,\n return_distance=True)\n if len(neighbors[0]) == 1:\n distances, neighbors = kdt.query(attributes[i:i + 1], k=2,\n return_distance=True)\n neighbors, distances = neighbors[0], distances[0]\n loop_ind = np.where(distances == 0)\n if len(loop_ind[0]) > 1:\n loop_ind = np.where(neighbors == i)\n neighbors = np.delete(neighbors, loop_ind)\n distances = np.delete(distances, loop_ind)\n # make distance into weights and fix zero distances\n edges_weights = [float(att_weight) / dist if dist > 0 else 1000 for dist in distances]\n len_neigh = len(neighbors)\n if len_neigh == 0:\n print('hi Im number ' + str(i))\n count += len_neigh\n mean = count / (i + 1)\n if i % 10 == 0:\n print('Progress:', i, '/', len(attributes), '; Current Mean:', mean) # 37273\n neighbors_translation = [dict_class_nodes_translation[kd_idx_to_class_idx[neighbor]] for neighbor in\n neighbors]\n weight_edges = list(zip(np.repeat(dict_class_nodes_translation[kd_idx_to_class_idx[i]], len(neighbors)),\n neighbors_translation, edges_weights))\n kg_imagenet.add_weighted_edges_from(weight_edges)\n # TODO: add the weight from the attributes to the pre graph and not replace them\n # (minor problem because it is sparse graph)\n largest_cc = max(nx.connected_components(kg_imagenet), key=len)\n kg_imagenet = kg_imagenet.subgraph(largest_cc).copy()\n return kg_imagenet\n\n def awa2_knowledge_graph(self):\n kg_imagenet = self.imagenet_knowledge_graph()\n awa2_split = json.load(open('materials/awa2-split.json', 'r'))\n train_wnids = awa2_split['train']\n test_wnids = awa2_split['test']\n relevant_nodes = list(chain(train_wnids, test_wnids))\n kg_awa2 = kg_imagenet.subgraph(relevant_nodes)\n return kg_awa2\n\n def create_labels_graph(self, dict_class_nodes_translation):\n labels_graph = nx.Graph()\n edges = np.array([(key, dict_class_nodes_translation[self.dict_idx_image_class[key]])\n for key in list(self.dict_idx_image_class.keys())]).astype(str)\n labels_graph.add_edges_from(edges)\n return labels_graph\n\n def weighted_graph(self, images_gnx, knowledge_graph, labels_graph, weights_dict):\n weighted_graph = nx.Graph()\n classes_nodes = knowledge_graph.nodes\n images_nodes = images_gnx.nodes\n labels_edges = labels_graph.edges\n images_edges = images_gnx.edges\n classes_edges = knowledge_graph.edges\n weighted_graph.add_nodes_from(images_nodes, key='movies')\n weighted_graph.add_nodes_from(classes_nodes, key='classes')\n # weighted_graph.add_edges_from(images_edges, key='images_edges')\n # weighted_graph.add_edges_from(classes_edges, key='classes_edges')\n # weighted_graph.add_edges_from(labels_edges, key='labels_edges')\n for edge in images_edges:\n dict_weight = images_gnx.get_edge_data(edge[0], edge[1])\n weight = dict_weight.get('weight')\n if weight is not None:\n weighted_graph.add_edge(edge[0], edge[1], weight=weight, key='images_edges')\n classes_weight = weights_dict['classes_edges']\n labels_weight = weights_dict['labels_edges']\n for edge in classes_edges:\n weighted_graph.add_edge(edge[0], edge[1], weight=classes_weight, key='images_edges')\n for edge in labels_edges:\n weighted_graph.add_edge(edge[0], edge[1], weight=labels_weight, key='labels_edges')\n images_nodes = np.array(images_nodes)\n random.Random(4).shuffle(images_nodes)\n classes_nodes = np.array(classes_nodes)\n random.Random(4).shuffle(classes_nodes)\n if self.images_nodes_percentage < 1:\n for image_node in images_nodes[0:int(len(images_nodes) * (1 - self.images_nodes_percentage))]:\n weighted_graph.remove_node(image_node)\n # for c in classes_nodes[0:int(len(classes_nodes) * 0.5)]:\n # weighted_graph.remove_node(c)\n return weighted_graph\n\n\ndef define_path(dataset_name):\n if dataset_name == \"awa2\":\n _data_path = 'ZSL _DataSets/awa2/Animals_with_Attributes2'\n _split_path = 'materials/awa2-split.json'\n _chkpt_path = \"save_data_graph/awa2\"\n elif dataset_name == \"cub\":\n _data_path = \"ZSL _DataSets/cub/CUB_200_2011\"\n _split_path = \"ZSL _DataSets/cub/CUB_200_2011/train_test_split_easy.mat\"\n _chkpt_path = 'save_data_graph/cub'\n elif dataset_name == \"lad\":\n _data_path = \"ZSL _DataSets/lad\"\n _split_path = \"ZSL _DataSets/lad/split_zsl.txt\"\n _chkpt_path = 'save_data_graph/lad'\n else:\n raise ValueError(\"Wrong dataset name: replace with awa2/cub/lad\")\n return _data_path, _split_path, _chkpt_path\n\nif __name__ == '__main__':\n cuda = torch.cuda.is_available()\n # cuda = False\n parser = argparse.ArgumentParser()\n parser.add_argument('--dataset', dest=\"dataset\", help=' Name of the dataset', type=str, default=\"awa2\")\n parser.add_argument('--cnn', default='materials/resnet50-base.pth')\n # parser.add_argument('--cnn', default='save_awa2/resnet-fit/epoch-1.pth')\n # parser.add_argument('--pred', default='save_awa2/gcn-dense-att/epoch-30.pred')\n # parser.add_argument('--pred', default='save_awa2/gcn-basic/epoch-34.pred')\n if cuda:\n parser.add_argument('--gpu', default='0')\n else:\n parser.add_argument('--gpu', default='-1')\n # parser.add_argument('--consider-trains', action='store_true')\n parser.add_argument('--consider-trains', action='store_false')\n\n parser.add_argument('--output', default=None)\n parser.add_argument('--images_threshold', default=0.10)\n parser.add_argument('--images_nodes_percentage', default=1)\n args = parser.parse_args()\n\n set_gpu(args.gpu)\n data_path, split_path, save_path = define_path(args.dataset)\n graph_preparation = ImagesEmbeddings(args, data_path, split_path, save_path)\n dict_name_class, dict_class_name = graph_preparation.dict_name_class, graph_preparation.dict_class_name\n seen_classes, unseen_classes = graph_preparation.seen_classes, graph_preparation.unseen_classes\n embeds_matrix, dict_image_embed, dict_image_class = graph_preparation.images_embed_calculator()\n # try:\n # dict_image_class_new = {image: dict_name_class[dict_image_class[image]]\n # for image in list(dict_image_class.keys())}\n # except:\n # dict_image_class_new = dict_image_class.copy()\n dict_idx_image_class = {i: dict_name_class[dict_image_class[image]]\n for i, image in enumerate(list(dict_image_class.keys()))}\n awa2_graph_creator = Awa2GraphCreator(embeds_matrix, dict_image_embed, dict_name_class, dict_idx_image_class,\n args.images_nodes_percentage, args)\n image_graph = awa2_graph_creator.create_image_graph()\n kg, dict_class_nodes_translation = awa2_graph_creator.imagenet_knowledge_graph()\n att_weight = 10\n kg = awa2_graph_creator.attributed_graph(kg, att_weight)\n seen_classes = [dict_class_nodes_translation[c] for c in seen_classes]\n unseen_classes = [dict_class_nodes_translation[c] for c in unseen_classes]\n split = {'seen': seen_classes, 'unseen': unseen_classes}\n labels_graph = awa2_graph_creator.create_labels_graph(dict_class_nodes_translation)\n weights = [1, 1]\n weights_dict = {'classes_edges': weights[0], 'labels_edges': weights[1]}\n awa2_graph = awa2_graph_creator.weighted_graph(image_graph, kg, labels_graph, weights_dict)\n print(len(image_graph.edges))\n print((len(image_graph.nodes)))\n print(len(kg.edges))\n print((len(kg.nodes)))\n print(len(labels_graph.edges))\n print((len(awa2_graph.edges)))\n" ]

[ [ "numpy.abs", "numpy.random.seed", "numpy.logspace", "numpy.subtract", "sklearn.metrics.pairwise.cosine_similarity", "numpy.ones", "numpy.concatenate", "numpy.argmax", "torch.cuda.is_available", "numpy.column_stack", "numpy.argsort", "numpy.repeat", "numpy.array", "numpy.zeros", "numpy.where", "matplotlib.pyplot.figure" ], [ "torch.load", "torch.cat", "torch.utils.data.DataLoader", "sklearn.neighbors.KDTree", "numpy.save", "numpy.concatenate", "sklearn.preprocessing.normalize", "numpy.delete", "torch.no_grad", "torch.cuda.is_available", "numpy.load", "numpy.array", "numpy.where" ] ]

HypnosPy/HypnosPy

[ "28b17d07ee78f7714bbbbd66f6253764addf9d94" ]

[ "healthyForce/MTLModels.py" ]

[ "import torch\nimport torch.nn as nn\nimport torch.optim as optim\nimport numpy as np\n\nclass MTL:\n def __init__(self):\n pass\n\n def aggregate_losses(self, losses):\n pass\n\n def adjust_after_validation(self, losses, epoch):\n pass\n\n\nclass MTLRandom(MTL):\n def __init__(self, ntasks, verbose=1):\n self.ntasks = ntasks\n\n def aggregate_losses(self, losses):\n return losses[np.random.randint(self.ntasks)]\n\n def adjust_after_validation(self, losses, epoch):\n return\n\n\nclass MTLUncertanty(MTL):\n\n def __init__(self, ntasks):\n\n super(MTLUncertanty, self).__init__()\n\n self.ntasks = ntasks\n # We have to be set in the Lightning Module\n #self.logsigma = nn.Parameter(torch.zeros(self.ntasks))\n self.logsigma = None\n\n def aggregate_losses(self, losses):\n \"\"\"\n Input: a list/set/dict of losses\n Output: a single value\n \"\"\"\n total_loss = 0\n for i, l in enumerate(losses):\n total_loss = total_loss + (l / (2. * torch.exp(self.logsigma[i])) + (self.logsigma[i]/2.))\n return total_loss\n\n def adjust_after_validation(self, losses, epoch):\n return\n\nclass MTLEqual(MTL):\n\n def __init__(self, ntasks):\n\n super(MTLEqual, self).__init__()\n self.ntasks = ntasks\n\n def aggregate_losses(self, losses):\n return sum(losses) / self.ntasks\n\n def adjust_after_validation(self, losses, epoch):\n return\n\nclass MTLDWA(MTL):\n\n def __init__(self, ntasks, algorithm, temperature=2, min_epochs_to_start=2, verbose=1):\n\n super(MTLDWA, self).__init__()\n self.ntasks = ntasks\n self.lambda_weight = torch.ones(self.ntasks)\n self.loss_t_1 = torch.ones(self.ntasks)\n self.loss_t_2 = torch.ones(self.ntasks)\n self.temperature = torch.ones(1) * temperature\n self.min_epochs_to_start = min_epochs_to_start\n\n self.algorithm = algorithm\n\n # Variables for ewa and trend version of DWA\n self.verbose = verbose\n self.max_epochs = 100\n self.history = torch.zeros(self.ntasks, self.max_epochs)\n self.winsize = 3\n\n #data = np.array([0,1,200,300,-10,20,10,-20,10,-20,1000])\n #ewma(data, 5, 0.9), trend(data[5:10])\n\n\n def aggregate_losses(self, losses):\n total_loss = 0\n #self.lambda_weight = self.lambda_weight.type_as(losses[0])\n for i, l in enumerate(losses):\n total_loss += (self.lambda_weight[i] * l)\n return total_loss / self.ntasks\n\n def adjust_after_validation(self, losses, epoch):\n\n for i in range(self.ntasks):\n self.loss_t_2[i] = self.loss_t_1[i]\n self.loss_t_1[i] = losses[i].item()\n\n if epoch >= self.min_epochs_to_start:\n\n if self.algorithm != \"default\":\n saved_from_epoch = epoch - self.min_epochs_to_start\n\n w = {}\n denominator = 0\n\n for i in range(self.ntasks):\n if self.algorithm == \"default\":\n w[i] = min(80., self.loss_t_1[i] / self.loss_t_2[i])\n else:\n self.history[i][saved_from_epoch] = min(80., self.loss_t_1[i] / self.loss_t_2[i])\n if self.algorithm == \"trend\":\n w[i] = trend(self.history[i][max(0, saved_from_epoch-self.winsize):saved_from_epoch])\n print(\"values:\", self.history[i][max(0, saved_from_epoch-self.winsize):saved_from_epoch])\n elif self.algorithm == \"ewma\":\n # Todo: need to implement a torch version of it\n w[i] = trend(self.history[i][max(0, saved_from_epoch-self.winsize):saved_from_epoch])\n\n if self.verbose > 0:\n print(\"w(%d) = %.4f\" % (i, w[i]))\n\n denominator += torch.exp(w[i]/self.temperature)\n\n for i in range(self.ntasks):\n numerator = self.ntasks * torch.exp(w[i]/self.temperature)\n self.lambda_weight[i] = numerator / denominator\n\n if self.verbose > 0:\n for i in range(self.ntasks):\n print(\"Lambda (%d) = %.4f\" % (i, self.lambda_weight[i]))\n\n\nclass MTLBandit(MTL):\n\n def __init__(self, ntasks,\n # \"bandit_alg_weight_assignment\"\n # algorithm: [ucb, ducb]\n # reward method: [l1/l2, l2/l1, l2-l1]\n # loss_assignment: [\"one\", \"priority\", \"all\"]\n strategy=\"bandit_ucb_l1l2_one\",\n min_epochs_to_start=2, verbose=1):\n\n super(MTLBandit, self).__init__()\n\n self.ntasks = ntasks\n\n self.bandit_alg = strategy.split(\"_\")[1]\n self.bandit_reward_method = strategy.split(\"_\")[2]\n self.bandit_loss_assignment = strategy.split(\"_\")[3]\n\n self.lambda_weight = torch.ones(self.ntasks)\n self.loss_t_1 = torch.ones(self.ntasks)\n self.loss_t_2 = torch.ones(self.ntasks)\n\n self.max_epochs = 100\n self.current_weight = torch.zeros(self.ntasks)\n self.reward = torch.zeros(self.max_epochs, self.ntasks)\n self.counts = torch.zeros(self.ntasks)\n self.chosen = torch.zeros(self.max_epochs, self.ntasks)\n\n self.gammas = torch.zeros(self.max_epochs) + 0.99\n\n self.min_epochs_to_start = min_epochs_to_start\n\n self.verbose = verbose\n\n def aggregate_losses(self, losses):\n total_loss = 0\n for i, l in enumerate(losses):\n total_loss += ((self.lambda_weight[i] * l) / self.ntasks)\n return total_loss\n\n def adjust_after_validation(self, losses, epoch):\n\n print(\"Current epoch:\", epoch)\n\n selected_task_i = -1\n\n for i in range(self.ntasks):\n self.loss_t_2[i] = self.loss_t_1[i]\n self.loss_t_1[i] = losses[i].item()\n\n if self.bandit_reward_method == \"l1l2\":\n self.reward[epoch][i] = min(80., self.loss_t_1[i] / self.loss_t_2[i])\n elif self.bandit_reward_method == \"l2l1\":\n self.reward[epoch][i] = min(80., self.loss_t_2[i] / self.loss_t_1[i])\n elif self.bandit_reward_method == \"l2-l1\":\n self.reward[epoch][i] = min(80., self.loss_t_2[i] - self.loss_t_1[i])\n\n if epoch >= self.min_epochs_to_start:\n\n if self.bandit_alg == \"ducb\":\n t_minus_s = get_t_minus_s(self.max_epochs, epoch)\n discount = self.gammas ** t_minus_s\n n_t_gamma = 0\n for i in range(self.ntasks):\n n_t_gamma += (discount * self.chosen[:, i]).sum()\n\n\n # TODO: I could replace this 'for' by a vectorized operation.\n for i in range(self.ntasks):\n # UBC1\n if self.bandit_alg == \"ucb\":\n\n avg_reward = (self.chosen[:, i] * self.reward[:, i]).sum() / self.chosen[:, i].sum()\n padding = np.sqrt(2.0 * np.log(epoch+1) / (1 + self.counts[i]))\n self.current_weight[i] = avg_reward + padding\n\n # discounted UBC -- very inefficient. Needs improvement\n elif self.bandit_alg == \"ducb\":\n\n N_t_gamma = (discount * self.chosen[:, i]).sum()\n avg_reward = (discount * self.reward[:, i]).sum() / N_t_gamma\n\n padding = 2.0 * np.sqrt(np.log(n_t_gamma)/N_t_gamma)\n\n self.current_weight[i] = avg_reward + padding\n\n else:\n print(\"Unkonwn bandit algorithm %s. Options are 'ubc' and 'ducb'\" % (self.bandit_alg))\n\n\n if self.verbose > 0:\n print(\"Current Reward(%d): %.3f (%.3f + %.3f)\" % (i,\n self.current_weight[i],\n avg_reward,\n padding\n )\n )\n selected_task_i = torch.argmax(self.current_weight).item()\n self.counts[selected_task_i] += 1\n self.chosen[epoch][selected_task_i] = 1\n\n if self.bandit_loss_assignment == \"all\":\n for x in range(self.ntasks):\n self.lambda_weight[x] = self.current_weight[x]\n\n elif self.bandit_loss_assignment in [\"one\", \"priority\"]:\n self.lambda_weight[selected_task_i] = 1\n for task_j in range(self.ntasks):\n if task_j != selected_task_i:\n if self.bandit_loss_assignment == \"priority\":\n self.lambda_weight[task_j] = 0.5\n else:\n self.lambda_weight[task_j] = 0.0\n\n else:\n # In case the algorithm has not started yet, we are \"choosing\" all arms\n for x in range(self.ntasks):\n self.chosen[epoch][x] = 1\n\n\n if self.verbose > 0:\n print(\"Selected Task:\", selected_task_i)\n for i in range(self.ntasks):\n print(\"W(%d): %.3f, Counts(%d): %d\" % (i, self.current_weight[i], i, self.counts[i]))\n for i in range(self.ntasks):\n print(\"Lambdas (%d) = %.4f\" % (i, self.lambda_weight[i]))\n" ]

[ [ "numpy.log", "torch.ones", "torch.zeros", "torch.argmax", "torch.exp", "numpy.random.randint" ] ]

raphaelchaves/transitionMatrix

[ "6ac54c8c6ce15dc81aa5e894cfcfabb127634b33" ]

[ "examples/python/matrix_from_duration_data.py" ]

[ "# encoding: utf-8\n\n# (c) 2017-2020 Open Risk, all rights reserved\n#\n# TransitionMatrix is licensed under the Apache 2.0 license a copy of which is included\n# in the source distribution of TransitionMatrix. This is notwithstanding any licenses of\n# third-party software included in this distribution. You may not use this file except in\n# compliance with the License.\n#\n# Unless required by applicable law or agreed to in writing, software distributed under\n# the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n# either express or implied. See the License for the specific language governing permissions and\n# limitations under the License.\n\n\n\"\"\"\nExample workflows using transitionMatrix to estimate a matrix from duration type data\nThe datasets are produced in examples/generate_synthetic_data.py\n\n\"\"\"\n\nimport pandas as pd\n\nimport transitionMatrix as tm\nfrom transitionMatrix import source_path\nfrom transitionMatrix.estimators import cohort_estimator as es\n\ndataset_path = source_path + \"datasets/\"\n\n# Select the example to run\n# 1-> An example with limited data (dataset contains only one entity)\n# 2-> A full example with a 2x2 matrix\n# 3-> A full example with a 8x8 matrix\n\nexample = 3\n\nif example == 1:\n\n # An example with limited data (dataset contains only one entity)\n data = pd.read_csv(dataset_path + 'synthetic_data1.csv', dtype={'State': str})\n sorted_data = data.sort_values(['ID', 'Time'], ascending=[True, True])\n myState = tm.StateSpace([('0', \"A\"), ('1', \"B\"), ('2', \"C\"), ('3', \"D\")])\n print(\"> Validate data set\")\n print(myState.validate_dataset(dataset=sorted_data))\n # Bin the data into 5 intervals\n cohort_data, cohort_intervals = tm.utils.bin_timestamps(data, cohorts=5)\n myEstimator = es.CohortEstimator(states=myState, ci={'method': 'goodman', 'alpha': 0.05})\n labels = {'Timestamp': 'Cohort', 'State': 'State', 'ID': 'ID'}\n result = myEstimator.fit(cohort_data, labels=labels)\n # Check significance of some estimates\n # First period\n myEstimator.summary(k=0)\n # Last period\n myEstimator.summary(k=4)\n\nelif example == 2:\n\n # Step 1\n # Load the data set into a pandas frame\n # Make sure state is read as a string and not as integer\n # Second synthetic data example:\n # n entities with ~10 observations each, [0,1] state, 50%/50% transition matrix\n print(\"> Step 1: Load the data\")\n data = pd.read_csv(dataset_path + 'synthetic_data2.csv', dtype={'State': str})\n sorted_data = data.sort_values(['ID', 'Time'], ascending=[True, True])\n print(sorted_data.describe())\n\n # Step 2\n # Describe and validate the State Space against the data\n print(\"> Step 2: Validate against state space\")\n myState = tm.StateSpace([('0', \"Basic\"), ('1', \"Default\")])\n myState.describe()\n print(myState.validate_dataset(dataset=sorted_data))\n\n # Step 3\n # Arrange the data in period cohorts\n print(\"> Step 3: Arrange the data in period cohorts\")\n cohort_data, cohort_intervals = tm.utils.bin_timestamps(data, cohorts=5)\n\n # Step 4\n # Estimate matrices using method of choice\n # compute confidence interval using goodman method at 95% confidence level\n print(\"> Step 4: Estimate matrices\")\n myEstimator = es.CohortEstimator(states=myState, ci={'method': 'goodman', 'alpha': 0.05})\n labels = {'Timestamp': 'Cohort', 'State': 'State', 'ID': 'ID'}\n result = myEstimator.fit(cohort_data, labels=labels)\n\n # Step 5\n # Print out the set of estimated matrices\n print(\"> Step 5: Display results\")\n myMatrixSet = tm.TransitionMatrixSet(values=result, temporal_type='Incremental')\n print(myMatrixSet.temporal_type)\n myMatrixSet.print_matrix()\n\n\nelif example == 3:\n\n data = pd.read_csv(dataset_path + 'synthetic_data3.csv', dtype={'State': str})\n sorted_data = data.sort_values(['ID', 'Time'], ascending=[True, True])\n myState = tm.StateSpace([('0', \"A\"), ('1', \"B\"), ('2', \"C\"), ('3', \"D\"), ('4', \"E\"), ('5', \"F\"), ('6', \"G\")])\n print(myState.validate_dataset(dataset=sorted_data))\n cohort_data, cohort_intervals = tm.utils.bin_timestamps(data, cohorts=5)\n myEstimator = es.CohortEstimator(states=myState, ci={'method': 'goodman', 'alpha': 0.05})\n labels = {'Timestamp': 'Cohort', 'State': 'State', 'ID': 'ID'}\n result = myEstimator.fit(cohort_data, labels=labels)\n myMatrixSet = tm.TransitionMatrixSet(values=result, temporal_type='Incremental')\n myMatrixSet.print_matrix()\n" ]

[ [ "pandas.read_csv" ] ]

karino2/Pytorch-Handwritten-Mathematical-Expression-Recognition

[ "6c6139624c71fa68a0a386a94346cfab39d0f087" ]

[ "Train.py" ]

[ "'''\nPython 3.6 \nPytorch 0.4\nWritten by Hongyu Wang in Beihang university\n'''\nimport torch\nimport math\nimport torch.nn as nn\nfrom torch.autograd import Variable\nimport torch.nn.functional as F\nimport numpy\nimport torch.utils.data as data\nfrom data_iterator import dataIterator\nfrom Densenet_torchvision import densenet121\nfrom Attention_RNN import AttnDecoderRNN\nimport random\n\n# compute the wer loss\ndef cmp_result(label,rec):\n dist_mat = numpy.zeros((len(label)+1, len(rec)+1),dtype='int32')\n dist_mat[0,:] = range(len(rec) + 1)\n dist_mat[:,0] = range(len(label) + 1)\n for i in range(1, len(label) + 1):\n for j in range(1, len(rec) + 1):\n hit_score = dist_mat[i-1, j-1] + (label[i-1] != rec[j-1])\n ins_score = dist_mat[i,j-1] + 1\n del_score = dist_mat[i-1, j] + 1\n dist_mat[i,j] = min(hit_score, ins_score, del_score)\n dist = dist_mat[len(label), len(rec)]\n return dist, len(label)\n\ndef load_dict(dictFile):\n fp=open(dictFile)\n stuff=fp.readlines()\n fp.close()\n lexicon={}\n for l in stuff:\n w=l.strip().split()\n lexicon[w[0]]=int(w[1])\n print('total words/phones',len(lexicon))\n return lexicon\n\ndatasets=['./offline-train.pkl','./train_caption.txt']\nvalid_datasets=['./offline-test.pkl', './test_caption.txt']\ndictionaries=['./dictionary.txt']\nbatch_Imagesize=500000\nvalid_batch_Imagesize=500000\nbatch_size=1\nmaxlen=48\nmaxImagesize= 100000\nhidden_size = 256\nteacher_forcing_ratio = 0.5\n\nworddicts = load_dict(dictionaries[0])\nworddicts_r = [None] * len(worddicts)\nfor kk, vv in worddicts.items():\n worddicts_r[vv] = kk\n\n#load train data and test data\ntrain,train_label = dataIterator(\n datasets[0], datasets[1],worddicts,batch_size=batch_size,\n batch_Imagesize=batch_Imagesize,maxlen=maxlen,maxImagesize=maxImagesize\n )\nlen_train = len(train)\n\ntest,test_label = dataIterator(\n valid_datasets[0],valid_datasets[1],worddicts,batch_size=batch_size,\n batch_Imagesize=batch_Imagesize,maxlen=maxlen,maxImagesize=maxImagesize\n )\n\n\nclass custom_dset(data.Dataset):\n def __init__(self,train,train_label):\n self.train = train\n self.train_label = train_label\n\n def __getitem__(self, index):\n train_setting = torch.from_numpy(numpy.array(self.train[index]))\n label_setting = torch.from_numpy(numpy.array(self.train_label[index])).type(torch.LongTensor)\n\n size = train_setting.size()\n train_setting = train_setting.view(1,size[2],size[3])\n label_setting = label_setting.view(-1)\n return train_setting,label_setting\n\n def __len__(self):\n return len(self.train)\n\noff_image_train = custom_dset(train,train_label)\noff_image_test = custom_dset(test,test_label)\n\n# collate_fn is writting for padding imgs in batch. But now, I used batch_size=1, so this function has no effect. \ndef collate_fn(batch):\n batch.sort(key=lambda x: len(x[1]), reverse=True)\n img, label = zip(*batch)\n aa1 = 0\n bb1 = 0\n max_len = len(label[0])\n for j in range(len(img)):\n size = img[j].size()\n if size[1] > aa1:\n aa1 = size[1]\n if size[2] > bb1:\n bb1 = size[2]\n img_padding = torch.zeros(len(img),1,aa1,bb1).type(torch.FloatTensor)\n img_mask = torch.zeros(len(img),1,aa1,bb1).type(torch.FloatTensor)\n for ii in range (len(img)):\n size = img[ii].size()\n for ii1 in range (size[1]):\n for ii2 in range (size[2]):\n img_padding[ii][0][ii1][ii2] = img[ii][0][ii1][ii2]\n img_mask[ii][0][ii1][ii2] = 1\n img_padding = img_padding/255\n # img_padding_mask = torch.cat((img_padding,img_mask),1)\n\n label_padding = torch.zeros(len(label),max_len+1).type(torch.LongTensor)\n for i in range(len(label)):\n for i1 in range(len(label[i])):\n label_padding[i][i1] = label[i][i1]\n\n return img_padding, label_padding\n\ntrain_loader = torch.utils.data.DataLoader(\n dataset = off_image_train,\n batch_size = batch_size,\n shuffle = True,\n collate_fn = collate_fn,\n num_workers=8,\n )\ntest_loader = torch.utils.data.DataLoader(\n dataset = off_image_test,\n batch_size = batch_size,\n shuffle = True,\n collate_fn = collate_fn,\n num_workers=8,\n)\n\ndef my_train(target_length,attn_decoder1,\n output_highfeature, output_area,y,criterion,encoder_optimizer1,decoder_optimizer1,x_mean,dense_input):\n loss = 0\n\n # teacher_forcing is very useful in training RNN.\n use_teacher_forcing = True if random.random() < teacher_forcing_ratio else False\n\n decoder_input = Variable(torch.LongTensor([[111]]))\n decoder_input = decoder_input.cuda()\n decoder_hidden = attn_decoder1.initHidden()\n decoder_hidden = decoder_hidden*x_mean\n decoder_hidden = torch.tanh(decoder_hidden)\n attention_sum = Variable(torch.zeros(1,dense_input,output_area).cuda())\n decoder_attention = Variable(torch.zeros(1,dense_input,output_area).cuda())\n\n if use_teacher_forcing:\n encoder_optimizer1.zero_grad()\n decoder_optimizer1.zero_grad()\n my_num = 0\n\n for di in range(target_length):\n decoder_output, decoder_hidden, decoder_attention, attention_sum = attn_decoder1(decoder_input,\n decoder_hidden,\n output_highfeature,\n output_area,\n attention_sum,\n decoder_attention,\n dense_input)\n\n loss += criterion(decoder_output[0], y[:,di])\n my_num = my_num + 1\n if int(y[0][di]) == 0:\n break\n decoder_input = y[:,di]\n\n loss.backward()\n encoder_optimizer1.step()\n decoder_optimizer1.step()\n return loss.item()\n\n else:\n encoder_optimizer1.zero_grad()\n decoder_optimizer1.zero_grad()\n my_num = 0\n\n for di in range(target_length):\n decoder_output, decoder_hidden, decoder_attention,attention_sum= attn_decoder1(decoder_input, decoder_hidden,\n output_highfeature, output_area,\n attention_sum,decoder_attention,dense_input)\n #print(decoder_output.size()) 1*1*112\n #print(y.size()) 1*37\n topv, topi = decoder_output[0][0].topk(1)\n decoder_input = topi\n loss += criterion(decoder_output[0], y[:,di])\n my_num = my_num + 1\n\n # if int(topi[0]) == 0:\n # break\n\n loss.backward()\n encoder_optimizer1.step()\n decoder_optimizer1.step()\n return loss.item()\n\n#encoder = DenseNet121().cuda()\nencoder = densenet121().cuda()\n\n\npthfile = r'densenet121-a639ec97.pth'\npretrained_dict = torch.load(pthfile) \nencoder_dict = encoder.state_dict()\npretrained_dict = {k: v for k, v in pretrained_dict.items() if k in encoder_dict}\nencoder_dict.update(pretrained_dict)\nencoder.load_state_dict(encoder_dict)\n\nattn_decoder1 = AttnDecoderRNN(hidden_size,112,dropout_p=0.2).cuda()\n# attn_pre = torch.load('model/attn_decoder_lr0.00009_nopadding_baseline.pkl')\n# attn_dict = attn_decoder1.state_dict()\n# attn_pre = {k: v for k, v in attn_pre.items() if k in attn_dict}\n# attn_dict.update(attn_pre)\n# attn_decoder1.load_state_dict(attn_dict)\n# encoder.load_state_dict(torch.load('model/encoder_lr0.00009_nopadding.pkl'))\n# attn_decoder1.load_state_dict(torch.load('model/attn_decoder_lr0.00009_nopadding.pkl'))\n\nlr_rate = 0.00009\nencoder_optimizer1 = torch.optim.Adam(encoder.parameters(), lr=lr_rate)\ndecoder_optimizer1 = torch.optim.Adam(attn_decoder1.parameters(), lr=lr_rate)\n\ncriterion = nn.CrossEntropyLoss()\nexprate = 0\n#encoder.load_state_dict(torch.load('model/encoder_lr0.00009_nopadding_pre_GN_te05_d02.pkl'))\n#attn_decoder1.load_state_dict(torch.load('model/attn_decoder_lr0.00009_nopadding_pre_GN_te05_d02.pkl'))\n\nfor epoch in range(1000):\n\n # if using SGD optimizer\n # if epoch%8 == 0:\n # lr_rate = lr_rate/10\n # encoder_optimizer1 = torch.optim.SGD(encoder.parameters(), lr=lr_rate,momentum=0.9)\n # decoder_optimizer1 = torch.optim.SGD(attn_decoder1.parameters(), lr=lr_rate,momentum=0.9)\n\n running_loss=0\n whole_loss = 0\n\n encoder.train(mode=True)\n attn_decoder1.train(mode=True)\n\n # this is the train\n for step,(x,y) in enumerate(train_loader):\n x = Variable(x.cuda())\n y = Variable(y.cuda())\n\n # out is CNN featuremaps\n out = encoder(x)\n output_highfeature = out.squeeze(0)\n\n x_mean = torch.mean(output_highfeature)\n x_mean = float(x_mean)\n\n # dense_input is height and output_area is width which is bb\n output_area1 = output_highfeature.size()\n output_area = output_area1[2]\n dense_input = output_area1[1]\n target_length = y.size()[1]\n\n running_loss += my_train(target_length,attn_decoder1,output_highfeature,\n output_area,y,criterion,encoder_optimizer1,decoder_optimizer1,x_mean,dense_input)\n\n \n if step % 100 == 99:\n pre = ((step+1)/len_train)*100\n whole_loss += running_loss\n running_loss = running_loss/100\n print('epoch is %d, loading for %.3f%%, running_loss is %f' %(epoch,pre,running_loss))\n with open(\"training_data/running_loss_%.5f_pre_GN_te05_d02.txt\" %(lr_rate),\"a\") as f:\n f.write(\"%s\\n\"%(str(running_loss)))\n running_loss = 0\n\n loss_all_out = whole_loss / len_train\n print(\"epoch is %d, the whole loss is %f\" % (epoch, loss_all_out))\n with open(\"training_data/whole_loss_%.5f_pre_GN_te05_d02.txt\" % (lr_rate), \"a\") as f:\n f.write(\"%s\\n\" % (str(loss_all_out)))\n\n # this is the prediction and compute wer loss\n total_dist = 0\n total_label = 0\n total_line = 0\n total_line_rec = 0\n\n encoder.eval()\n attn_decoder1.eval()\n\n for step_t, (x_t, y_t) in enumerate(test_loader):\n x_t = Variable(x_t.cuda())\n y_t = Variable(y_t.cuda())\n out_t = encoder(x_t)\n output_highfeature_t = out_t.squeeze(0)\n x_mean_t = torch.mean(output_highfeature_t)\n x_mean_t = float(x_mean_t)\n output_area_t1 = output_highfeature_t.size()\n output_area_t = output_area_t1[2]\n dense_input = output_area_t1[1]\n target_length_t = y_t.size()[1]\n\n decoder_input_t = Variable(torch.LongTensor([[111]]))\n decoder_input_t = decoder_input_t.cuda()\n decoder_hidden_t = attn_decoder1.initHidden()\n decoder_hidden_t = decoder_hidden_t * x_mean_t\n decoder_hidden_t = torch.tanh(decoder_hidden_t)\n\n prediction = []\n label = []\n decoder_attention_t = Variable(torch.zeros(1,dense_input,output_area_t).cuda())\n attention_sum_t = Variable(torch.zeros(1,dense_input,output_area_t).cuda())\n for i in range(48):\n decoder_output, decoder_hidden_t, decoder_attention_t, attention_sum_t = attn_decoder1(decoder_input_t,\n decoder_hidden_t,\n output_highfeature_t,\n output_area_t,\n attention_sum_t,\n decoder_attention_t,dense_input)\n topv, topi = decoder_output[0].topk(1)\n decoder_input_t = topi\n\n # prediction\n prediction.append(int(topi[0]))\n if int(topi[0]) == 0:\n break\n # label\n for i_label in range(target_length_t):\n label.append(int(y_t[0][i_label]))\n #label.append(0)\n\n dist, llen = cmp_result(label, prediction)\n total_dist += dist\n total_label += llen\n total_line += 1\n if dist == 0:\n total_line_rec = total_line_rec+ 1\n\n print('total_line_rec is',total_line_rec)\n wer = float(total_dist) / total_label\n sacc = float(total_line_rec) / total_line\n print('wer is %.5f' % (wer))\n print('sacc is %.5f ' % (sacc))\n with open(\"training_data/wer_%.5f_pre_GN_te05_d02.txt\" % (lr_rate), \"a\") as f:\n f.write(\"%s\\n\" % (str(wer)))\n\n\n if (sacc > exprate):\n exprate = sacc\n print(exprate)\n print(\"saving the model....\")\n print('encoder_lr%.5f_nopadding_pre_GN_te05_d02_f.pkl' %(lr_rate))\n torch.save(encoder.state_dict(), 'model/encoder_lr%.5f_nopadding_pre_GN_te05_d02_f.pkl'%(lr_rate))\n torch.save(attn_decoder1.state_dict(), 'model/attn_decoder_lr%.5f_nopadding_pre_GN_te05_d02_f.pkl'%(lr_rate))\n print(\"done\")\n else:\n print('the best is %f' % (exprate))\n print('the loss is bigger than before,so do not save the model')\n\n\n\n\n\n\n\n\n\n\n" ]

[ [ "torch.mean", "torch.LongTensor", "torch.nn.CrossEntropyLoss", "torch.load", "torch.zeros", "torch.utils.data.DataLoader", "torch.tanh", "numpy.array" ] ]

PlusLabNLP/PredictiveEngagement

[ "214d3eb20901982d192b05b4d496420dfb273f8e" ]

[ "pytorch_src/engagement_classifier.py" ]

[ "import random\nimport numpy as np\nimport torch \nimport torch.optim as optim\nimport matplotlib.pyplot as plt\nfrom sklearn.metrics import classification_report, roc_auc_score\nimport pickle\nimport torch.nn as nn\nimport os \nimport csv\n\nrandom.seed(1000)\nnp.random.seed(1000)\ntorch.manual_seed(1000)\n# torch.backends.cudnn.benchmark = False\n# torch.backends.cudnn.deterministic = True\n# torch.backends.cudnn.enabled = False\n\nclass Engagement_cls():\n '''This class classifies each query and response pairs as 0(not engaging) or 1 (engaging)\n '''\n def __init__(self, train_dir, batch_size, mlp_hidden_dim, num_epochs,\\\n regularizer = 0.01, lr=1e-4, dropout = 0.1, optimizer=\"Adam\",\\\n ftrain_queries_embed=None, ftrain_replies_embed=None, fvalid_queries_embed=None, fvalid_replies_embed=None, ftest_queries_embed=None ,ftest_replies_embed=None):\n print('***************model parameters********************')\n print('mlp layers {}'.format(mlp_hidden_dim))\n print('learning rate {}'.format(lr))\n print('drop out rate {}'.format(dropout))\n print('batch size {}'.format(batch_size))\n print('optimizer {}'.format(optimizer))\n print('regularizer {}'.format(regularizer))\n print('***************************************************')\n print(ftrain_queries_embed)\n print(ftrain_replies_embed)\n print(fvalid_queries_embed)\n print(fvalid_replies_embed)\n print(ftest_queries_embed)\n print(ftest_replies_embed)\n\n self.train_dir = train_dir\n self.batch_size = batch_size\n self.mlp_hidden_dim = mlp_hidden_dim\n self.lr = lr\n self.dropout = dropout\n self.num_epochs = num_epochs\n self.optim = optimizer\n self.reg= regularizer\n self.ftrain_queries_embed = ftrain_queries_embed\n self.ftrain_replies_embed =ftrain_replies_embed\n self.fvalid_queries_embed= fvalid_queries_embed\n self.fvalid_replies_embed = fvalid_replies_embed\n self.ftest_queries_embed = ftest_queries_embed\n self.ftest_replies_embed = ftest_replies_embed\n\n def load_Bert_embeddings(self, data_dir, f_queries_embed, f_replies_embed):\n '''Load sentences Bert embeddings into dictionary \n '''\n print('Loading Bert embeddings of sentences')\n queries_vectors = {}\n replies_vectors = {}\n fwq = open(data_dir+f_queries_embed, 'rb')\n dict_queries = pickle.load(fwq)\n for query, embeds in dict_queries.items():\n queries_vectors[query] = embeds[0]\n\n fwr = open(data_dir + f_replies_embed, 'rb')\n dict_replies = pickle.load(fwr)\n for reply, embeds in dict_replies.items():\n replies_vectors[reply] = embeds[0]\n print('number of loaded embeddings is {} {}'.format(len(queries_vectors), len(replies_vectors)))\n return queries_vectors, replies_vectors\n \n \n def prepare_data(self, data_dir, ftrain=None, fvalid=None, ftest=None):\n '''Load train/valid/test utterance pairs and get their embeddings\n '''\n self.data_dir = data_dir \n if ftrain != None:\n csv_file = open(data_dir + ftrain)\n csv_reader_train = csv.reader(csv_file, delimiter=',')\n self.train_queries,self.train_replies,self.train_labels = [],[],[]\n next(csv_reader_train)\n for row in csv_reader_train:\n self.train_queries.append(row[1].split('\\n')[0])\n self.train_replies.append(row[2].split('\\n')[0])\n self.train_labels.append(int(row[3]))\n print('size of train_queries {}'.format(len(self.train_queries)))\n self.train_size = len(self.train_queries)\n self.train_queries_embeds, self.train_replies_embeds= self.load_Bert_embeddings(data_dir, self.ftrain_queries_embed, self.ftrain_replies_embed)\n\n if fvalid != None:\n csv_file = open(data_dir + fvalid)\n csv_reader_valid = csv.reader(csv_file, delimiter=',')\n self.valid_queries,self.valid_replies,self.valid_labels= [],[],[]\n next(csv_reader_valid)\n for row in csv_reader_valid:\n self.valid_queries.append(row[1].split('\\n')[0])\n self.valid_replies.append(row[2].split('\\n')[0])\n self.valid_labels.append(int(row[3]))\n print('size of valid_queries {}'.format(len(self.valid_queries)))\n self.valid_size = len(self.valid_queries)\n self.valid_queries_embeds, self.valid_replies_embeds= self.load_Bert_embeddings(data_dir, self.fvalid_queries_embed, self.fvalid_replies_embed)\n\n\n if ftest != None:\n print(self.ftest_queries_embed)\n print(self.ftest_replies_embed)\n csv_file = open(data_dir + ftest)\n csv_reader_test = csv.reader(csv_file, delimiter=',')\n\n self.test_queries,self.test_replies,self.test_labels = [],[],[]\n next(csv_reader_test)\n for row in csv_reader_test:\n self.test_queries.append(row[1].split('\\n')[0])\n self.test_replies.append(row[2].split('\\n')[0])\n self.test_labels.append(int(row[3]))\n self.test_size = len(self.test_queries)\n self.test_queries_embeds, self.test_replies_embeds= self.load_Bert_embeddings(data_dir, self.ftest_queries_embed, self.ftest_replies_embed)\n\n filename = self.train_dir + \"log_train.txt\"\n os.makedirs(os.path.dirname(filename), exist_ok=True)\n self.fw =open(filename, \"a\")\n self.fw.write('***************model parameters******************** \\n')\n self.fw.write('mlp layers {} \\n'.format(self.mlp_hidden_dim))\n self.fw.write('learning rate {}\\n'.format(self.lr))\n self.fw.write('drop out rate {}\\n'.format(self.dropout))\n self.fw.write('batch size {}\\n'.format(self.batch_size))\n self.fw.write('optimizer {}\\n'.format(self.optim))\n self.fw.write('regularizer {}'.format(self.reg))\n self.fw.write('***************************************************\\n')\n \n \n \n def shuffle_data(self, type='train'):\n '''Shuffle queries/replies/engagement scores for train/valid/test sets \n '''\n if type=='train':\n train_indexes = [i for i in range(self.train_size)] \n random.shuffle(train_indexes)\n shuffled_queries = []\n shuffled_replies = []\n shuffled_labels = []\n shuffled_replies_len = []\n shuffled_replies_num_diverse= []\n\n for i in train_indexes:\n shuffled_queries.append(self.train_queries[i]) \n shuffled_replies.append(self.train_replies[i])\n shuffled_labels.append(self.train_labels[i])\n\n self.train_queries = shuffled_queries\n self.train_replies = shuffled_replies\n self.train_labels = shuffled_labels\n\n elif type=='valid':\n valid_indexes = [i for i in range(self.valid_size)] \n random.shuffle(valid_indexes)\n shuffled_queries = []\n shuffled_replies = []\n shuffled_labels = []\n\n for i in valid_indexes:\n shuffled_queries.append(self.valid_queries[i]) \n shuffled_replies.append(self.valid_replies[i])\n shuffled_labels.append(self.valid_labels[i])\n\n self.valid_queries = shuffled_queries\n self.valid_replies = shuffled_replies\n self.valid_labels = shuffled_labels\n\n elif type=='test':\n test_indexes = [i for i in range(self.test_size)] \n random.shuffle(test_indexes)\n shuffled_queries = []\n shuffled_replies = []\n shuffled_labels = []\n\n for i in test_indexes:\n shuffled_queries.append(self.test_queries[i]) \n shuffled_replies.append(self.test_replies[i])\n shuffled_labels.append(self.test_labels[i])\n\n self.test_queries = shuffled_queries\n self.test_replies = shuffled_replies\n self.test_labels = shuffled_labels\n\n \n def train(self, early_stop=50, finetune=False):\n \n model = BiLSTM(mlp_hidden_dim=self.mlp_hidden_dim, dropout=self.dropout)\n if torch.cuda.is_available():\n model.cuda()\n max_auc = 0\n no_improve_epoch = 0\n no_improve_in_previous_epoch = False\n\n if finetune==False:\n model_name ='best_model' \n if finetune==True:\n model_name ='best_model_finetuned'\n #load pretrained model\n model.load_state_dict(torch.load(self.train_dir + 'best_model.pt'))\n info = torch.load(self.train_dir + 'best_model.info')\n print('the parameters of the best trained model is ')\n for name, param in model.named_parameters():\n if param.requires_grad:\n print (name, param.data, param.shape)\n print(self.lr)\n if self.optim=='SGD':\n optimizer = optim.SGD(model.parameters(), lr=self.lr, weight_decay=self.reg)\n if self.optim=='Adam':\n optimizer = optim.Adam(model.parameters(), lr=self.lr, weight_decay=self.reg)\n if self.optim=='RMSprop':\n optimizer = optim.RMSprop(model.parameters(), lr=self.lr, weight_decay=self.reg)\n\n plot_train_auc = []\n plot_valid_auc = []\n plot_valid_loss = []\n plot_train_loss = []\n plot_ep = []\n step=0\n #Shuffle valid data once since original file first has all the utterances with engagement score=0 and then all the utterances with engagement score=1\n self.shuffle_data('valid') \n\n for e in range(self.num_epochs):\n print('***********************************************')\n print(e)\n if no_improve_in_previous_epoch:\n no_improve_epoch += 1\n if no_improve_epoch >= early_stop:\n break\n else:\n no_improve_epoch = 0\n no_improve_in_previous_epoch = True\n\n train_loss = []\n train_auc = []\n nonzero_total= 0\n list_preds = torch.tensor([self.train_size])\n list_grtuth = torch.tensor([self.train_size])\n if torch.cuda.is_available():\n list_preds = list_preds.cuda()\n list_grtuth = list_grtuth.cuda()\n self.shuffle_data('train')\n\n for stidx in range(0, self.train_size, self.batch_size):\n step+=1\n model.train()\n model.zero_grad()\n x_q = self.train_queries[stidx:stidx + self.batch_size]\n x_r = self.train_replies[stidx:stidx + self.batch_size]\n y = torch.tensor(self.train_labels[stidx:stidx + self.batch_size]).long()\n \n if torch.cuda.is_available():\n y = y.cuda()\n nonzero = torch.nonzero(y).size(0)\n nonzero_total +=nonzero\n model_output = model(x_q, x_r, self.train_queries_embeds, self.train_replies_embeds)\n\n pred_eval = torch.argmax(model_output, 1)\n \n\n list_preds = torch.cat((list_preds, pred_eval), dim=0)\n list_grtuth = torch.cat((list_grtuth, y), dim=0)\n \n #calculate weights for each class\n weight = torch.tensor([y.shape[0]/(2*(y.shape[0]- nonzero)), y.shape[0]/(2*nonzero)])\n if torch.cuda.is_available():\n weight = weight.cuda()\n #weighted loss function due bacuase of imbalanced data \n loss_function = nn.CrossEntropyLoss(weight)\n loss = loss_function(model_output, y)\n train_loss.append(loss.data) \n loss.backward()\n optimizer.step()\n print('number of nonzero in train is {}'.format(nonzero_total))\n #calculate the evaluation metric and loss value for train data\n train_auc = roc_auc_score(list_grtuth[1:].detach().cpu().numpy(), list_preds[1:].detach().cpu().numpy())\n train_loss = torch.mean(torch.stack(train_loss))\n # train_loss = np.mean(train_loss)\n \n #evaluate trained model on valid data\n val_loss = []\n val_auc = []\n nonzero_total = 0\n list_preds_v = torch.tensor([self.valid_size])\n list_grtuth_v = torch.tensor([self.valid_size])\n if torch.cuda.is_available():\n list_preds_v = list_preds_v.cuda()\n list_grtuth_v = list_grtuth_v.cuda()\n for stidx in range(0, self.valid_size, self.batch_size):\n model.eval()\n val_x_q = self.valid_queries[stidx:stidx + self.batch_size]\n val_x_r = self.valid_replies[stidx:stidx + self.batch_size]\n val_y = torch.tensor(self.valid_labels[stidx:stidx + self.batch_size]).long()\n \n if torch.cuda.is_available():\n val_y = val_y.cuda()\n nonzero = torch.nonzero(val_y).size(0)\n nonzero_total +=nonzero\n model_output = model(val_x_q, val_x_r, self.valid_queries_embeds, self.valid_replies_embeds)\n val_pred = torch.argmax(model_output, 1)\n list_preds_v = torch.cat((list_preds_v, val_pred), dim=0)\n list_grtuth_v = torch.cat((list_grtuth_v, val_y), dim=0)\n\n weight = torch.tensor([val_y.shape[0]/(2*(val_y.shape[0]- nonzero)), val_y.shape[0]/(2*nonzero)])\n if torch.cuda.is_available():\n weight = weight.cuda()\n loss_function = nn.CrossEntropyLoss(weight)\n v_loss = loss_function(model_output, val_y)\n\n val_loss.append(v_loss.data)\n\n val_auc = roc_auc_score(list_grtuth_v[1:].detach().cpu().numpy(), list_preds_v[1:].detach().cpu().numpy())\n # val_loss = np.mean(val_loss)\n val_loss = torch.mean(torch.stack(val_loss))\n\n print('number of nonzero in valid is {}'.format(nonzero_total))\n \n st_improv = ''\n if val_auc > max_auc:\n st_improv = '*'\n torch.save({'step': step, 'epoch': e, 'train_loss': train_loss, 'train_auc': train_auc, 'val_loss': val_loss, 'val_auc': val_auc }, self.train_dir+model_name+'.info')\n torch.save(model.state_dict(), self.train_dir+model_name+'.pt')\n max_auc = val_auc\n no_improve_in_previous_epoch = False\n \n print('epcoh {:02} - train_loss {:.4f} - train_auc {:.4f} val_loss {:.4f} - val_auc {:.4f}{}'.format(\n e, train_loss, train_auc, val_loss, val_auc, st_improv))\n self.fw.write('epcoh {:02} - train_loss {:.4f} - train_auc {:.4f} val_loss {:.4f} - val_auc {:.4f}{} \\n'.format(\n e, train_loss, train_auc, val_loss, val_auc, st_improv))\n\n plot_train_auc.append(train_auc)\n plot_valid_auc.append(val_auc)\n plot_train_loss.append(train_loss)\n plot_valid_loss.append(val_loss)\n plot_ep.append(e)\n \n print('#############################################')\n model.load_state_dict(torch.load(self.train_dir + model_name+'.pt'))\n info = torch.load(self.train_dir + model_name+'.info')\n\n print('the parameters of the best trained model is ')\n for name, param in model.named_parameters():\n if param.requires_grad:\n print (name, param.data, param.shape)\n\n\n print('Done!')\n plt.figure(0) \n l1 = plt.plot(plot_ep,plot_train_auc,'-r', label='Train auc')\n l2 = plt.plot(plot_ep,plot_valid_auc,'-b', label='Valid auc')\n plt.legend(loc='upper left')\n plt.xlabel(\"train and valid acc for model\")\n plt.savefig(self.train_dir + 'model_auc.jpg')\n \n plt.figure(1) \n l1 = plt.plot(plot_ep,plot_train_loss,'-r', label='Train loss')\n l2 = plt.plot(plot_ep,plot_valid_loss,'-b', label='Valid loss')\n plt.legend(loc='upper left')\n plt.xlabel(\"train and valid loss for model\")\n plt.savefig(self.train_dir + 'model_loss.jpg')\n\n \n\n \n def test(self, fname):\n '''Test the trained model on test set\n '''\n if not os.path.isfile(self.train_dir+'best_model.pt'):\n print('There is not any trained model to be tested!\\nPlease first try to train the model.')\n return \n\n model = BiLSTM(mlp_hidden_dim=self.mlp_hidden_dim, dropout=self.dropout)\n if torch.cuda.is_available():\n model.cuda()\n model.load_state_dict(torch.load(self.train_dir+'best_model.pt'))\n info = torch.load(self.train_dir + 'best_model.info')\n model.eval()\n print('begining of test')\n for name, param in model.named_parameters():\n if param.requires_grad:\n print (name, param.data, param.shape)\n\n self.shuffle_data('test') \n test_loss = []\n test_auc = []\n nonzero_total= 0\n step = 0\n list_preds_t = torch.tensor([self.test_size])\n list_grtuth_t = torch.tensor([self.test_size])\n if torch.cuda.is_available():\n list_preds_t = list_preds_t.cuda()\n list_grtuth_t = list_grtuth_t.cuda()\n for stidx in range(0, self.test_size, self.batch_size):\n step+=1\n x_q = self.test_queries[stidx:stidx + self.batch_size]\n x_r = self.test_replies[stidx:stidx + self.batch_size]\n y = torch.tensor(self.test_labels[stidx:stidx + self.batch_size]).long()\n if torch.cuda.is_available():\n y = y.cuda()\n nonzero = torch.nonzero(y).size(0)\n nonzero_total +=nonzero\n model_output = model(x_q, x_r, self.test_queries_embeds, self.test_replies_embeds)\n pred_eval = torch.argmax(model_output, 1)\n list_preds_t = torch.cat((list_preds_t, pred_eval), dim=0)\n list_grtuth_t = torch.cat((list_grtuth_t, y), dim=0)\n print('batch {} has {} nonzero points and {} zero points overall {} points '.format(step, nonzero, y.shape[0]- nonzero, y.shape[0]))\n weight = torch.tensor([y.shape[0]/(2*(y.shape[0]- nonzero)), y.shape[0]/(2*nonzero)])\n if torch.cuda.is_available():\n weight = weight.cuda()\n loss_function = nn.CrossEntropyLoss(weight)\n loss = loss_function(model_output, y)\n test_loss.append(loss.data) \n print('number of nonzero in test is {}'.format(nonzero_total))\n\n test_auc = roc_auc_score(list_grtuth_t[1:].detach().cpu().numpy(), list_preds_t[1:].detach().cpu().numpy())\n print(classification_report(list_grtuth_t[1:].detach().cpu().numpy(), list_preds_t[1:].detach().cpu().numpy()))\n # test_loss = np.mean(test_loss)\n test_loss = torch.mean(torch.stack(test_loss))\n\n print('Test set: test_loss: {} -- test_auc: {}'.format(test_loss, test_auc))\n\n\n def generate_eng_score(self, fname_ground_truth, ofile):\n '''for all pairs of queries and replies predicts engagement scores\n Params:\n fname_ground_truth: file includes the queries and their ground-truth replies\n foname: file includes the queries, ground truth replies, generated replies (from self.test_replies) and engagement_score of queries and generated replies with following format:\n query===groundtruth_reply===generated_reply===engagement_score of query and generated_reply\n\n '''\n\n if not os.path.isfile(self.train_dir+'best_model_finetuned.pt'):\n print('There is not any finetuned model on DD dataset to be used!\\nPlease first try to finetune trained model.')\n return\n model = BiLSTM(mlp_hidden_dim=self.mlp_hidden_dim, dropout=self.dropout)\n if torch.cuda.is_available():\n model.cuda()\n model.load_state_dict(torch.load(self.train_dir + 'best_model_finetuned.pt'))\n info = torch.load(self.train_dir + 'best_model_finetuned.info')\n model.eval()\n\n fw_pred_labels = open(self.data_dir + ofile, 'w')\n fr_groundtruth_replies = open(self.data_dir + fname_ground_truth, 'r')\n groundtruth_replies =fr_groundtruth_replies.readlines() \n\n print('begining of prediction')\n for name, param in model.named_parameters():\n if param.requires_grad:\n print (name, param.data, param.shape)\n for stidx in range(0, self.test_size, self.batch_size):\n x_q = self.test_queries[stidx:stidx + self.batch_size]\n x_r = self.test_replies[stidx:stidx + self.batch_size]\n x_groundtruth_r = groundtruth_replies[stidx:stidx + self.batch_size]\n model_output = model(x_q, x_r, self.test_queries_embeds, self.test_replies_embeds)\n pred_eng = torch.nn.functional.softmax(model_output, dim=1)\n for ind in range(len(x_q)):\n fw_pred_labels.write(x_q[ind]+'==='+x_groundtruth_r[ind].split('\\n')[0]+'==='+x_r[ind]+'==='+str(pred_eng[ind][1].item())+'\\n')\n \n print('The engagingness score for specified replies has been predicted!')\n\n\n def get_eng_score(self, query, q_embed, reply, r_embed, model):\n '''for a pair of query and reply predicts engagement scores\n Params:\n query: input query\n q_embed: embeddings of query\n reply: input reply\n r_embed: embeddings of reply\n \n '''\n if not os.path.isfile(self.train_dir+'best_model_finetuned.pt'):\n print('There is not any finetuned model on DD dataset to be used!\\nPlease first try to finetune trained model.')\n return\n \n model = BiLSTM(mlp_hidden_dim=self.mlp_hidden_dim, dropout=self.dropout)\n if torch.cuda.is_available():\n model.cuda()\n model.load_state_dict(torch.load(self.train_dir + 'best_model_finetuned.pt'))\n info = torch.load(self.train_dir + 'best_model_finetuned.info')\n model.eval()\n\n model_output = model(query, reply, q_embed, r_embed)\n pred_eng = torch.nn.functional.softmax(model_output, dim=1)\n return pred_eng\n\n \n \n\n\nclass BiLSTM(nn.Module):\n '''The engagement classification model is a three layer mlp classifier with having tanh as activation functions which takes the embeddings of query and reply as input and pass their average into the mlp classifier\n '''\n def __init__(self, mlp_hidden_dim=[128], dropout=0.2):\n super(BiLSTM, self).__init__()\n self.dropout = nn.Dropout(p=dropout)\n num_classes=2\n self.mlp_hidden_0 = nn.Linear(768, mlp_hidden_dim[0], bias=True)\n self.mlp_hidden_1 = nn.Linear(mlp_hidden_dim[0], mlp_hidden_dim[1], bias=True)\n self.mlp_hidden_2 = nn.Linear(mlp_hidden_dim[1], mlp_hidden_dim[2], bias=True)\n self.mlp_out = nn.Linear(mlp_hidden_dim[2], num_classes, bias=True)\n\n\n def forward(self, queries_input, replies_input, queries_embeds, replies_embeds):\n\n for ind, q in enumerate(queries_input):\n if q not in queries_embeds.keys():\n print('the query {} embedding has not been found in the embedding file'.format(q))\n X_q = torch.tensor([queries_embeds[q] for q in queries_input])\n\n for ind, r in enumerate(replies_input):\n if r not in replies_embeds.keys():\n print('the reply {} embedding has not been found in the embedding file'.format(r))\n X_r = torch.tensor([replies_embeds[r] for r in replies_input])\n \n if torch.cuda.is_available():\n X_q, X_r = X_q.cuda(), X_r.cuda()\n mlp_input=X_q.add(X_r)\n mlp_input = torch.div(mlp_input,2)\n\n mlp_h_0 = torch.tanh(self.mlp_hidden_0(mlp_input))\n mlp_h_0= self.dropout(mlp_h_0)\n \n mlp_h_1 = torch.tanh(self.mlp_hidden_1(mlp_h_0))\n mlp_h_1= self.dropout(mlp_h_1)\n\n mlp_h_2 = torch.tanh(self.mlp_hidden_2(mlp_h_1))\n mlp_h_2= self.dropout(mlp_h_2)\n\n mlp_out= self.mlp_out(mlp_h_2)\n return mlp_out\n" ]

[ [ "matplotlib.pyplot.legend", "torch.nn.functional.softmax", "torch.load", "torch.cat", "matplotlib.pyplot.plot", "torch.cuda.is_available", "torch.save", "torch.nn.Dropout", "torch.nn.CrossEntropyLoss", "torch.tensor", "torch.nonzero", "matplotlib.pyplot.figure", "torch.div", "matplotlib.pyplot.savefig", "torch.nn.Linear", "torch.stack", "numpy.random.seed", "torch.manual_seed", "matplotlib.pyplot.xlabel", "torch.argmax" ] ]

keshuichonglx/tatk

[ "7e8ad18ca98b105cb0168192bddf80b747067c1b" ]

[ "tatk/policy/rule/camrest/rule.py" ]

[ "# -*- coding: utf-8 -*-\nimport torch\nfrom tatk.policy.policy import Policy\nfrom tatk.policy.rule.camrest.rule_based_camrest_bot import RuleBasedCamrestBot\nfrom tatk.policy.rule.camrest.policy_agenda_camrest import UserPolicyAgendaCamrest\n\nDEVICE = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n\nclass Rule(Policy):\n \n def __init__(self, is_train=False, character='sys'):\n self.is_train = is_train\n self.character = character\n\n if character == 'sys':\n self.policy = RuleBasedCamrestBot()\n elif character == 'usr':\n self.policy = UserPolicyAgendaCamrest()\n else:\n raise NotImplementedError('unknown character {}'.format(character))\n \n def predict(self, state):\n \"\"\"\n Predict an system action given state.\n Args:\n state (dict): Dialog state. Please refer to util/state.py\n Returns:\n action : System act, with the form of (act_type, {slot_name_1: value_1, slot_name_2, value_2, ...})\n \"\"\"\n return self.policy.predict(state)\n\n def init_session(self):\n \"\"\"\n Restore after one session\n \"\"\"\n self.policy.init_session()\n\n def is_terminated(self):\n if self.character == 'sys':\n return None\n return self.policy.is_terminated()\n\n def get_reward(self):\n if self.character == 'sys':\n return None\n return self.policy.get_reward()\n\n def get_goal(self):\n if hasattr(self.policy, 'get_goal'):\n return self.policy.get_goal()\n return None\n" ]

[ [ "torch.cuda.is_available" ] ]

lpierezan/cp_playground

[ "818d116391b762c1ca03be772a50bb997b7958a4" ]

[ "linalg/lu_decomp.py" ]

[ "import numpy as np\n\ndef lu_decomp(A):\n n = len(A)\n U = A.copy()\n L = np.eye(n)\n row_idx = list(range(n))\n\n for col in range(n):\n # find best row\n best_row, best_elem = None, None\n for row in range(col,n):\n row_i = row_idx[row]\n elem = U[row_i][col]\n if best_row is None or abs(elem) > best_elem:\n best_row = row\n best_elem = abs(elem)\n\n if best_elem == 0:\n #raise(Exception(\"Not full rank.\"))\n continue\n\n # swap rows: best_row and col\n L[row_idx[col]][col] = 0\n L[row_idx[col]][best_row] = 1\n L[row_idx[best_row]][best_row] = 0\n L[row_idx[best_row]][col] = 1\n row_idx[col], row_idx[best_row] = row_idx[best_row] , row_idx[col]\n best_row_i = row_idx[col]\n\n # normalize\n for row in range(col+1,n):\n row_i = row_idx[row]\n coef = U[row_i][col] / U[best_row_i][col]\n L[row_i][col] = coef\n U[row_i] = U[row_i] - U[best_row_i] * coef\n\n return L, U, row_idx\n\ndef solve_lu(L_,U_,p,b_):\n L = L_[p]\n U = U_[p]\n b = b_[p]\n\n n = len(L)\n z = np.zeros(n)\n x = np.zeros(n)\n \n # Lz = b\n # L[i,:i] * sum(z[:i,0] + z[i]) = b[i]\n for i in range(n):\n z[i] = b[i] - (L[i,:i] * z[:i]).sum()\n\n assert np.allclose(L.dot(z),b)\n\n # Ux = z\n # U[i,i] * x[i] + sum(U[i,i+1:] * x[i+1:]) = z[i]\n for i in range(n-1,-1,-1):\n acc = (z[i] - (U[i,i+1:] * x[i+1:]).sum())\n if(np.isclose(U[i,i], 0)):\n if(np.isclose(acc,0)):\n # multiple solutions\n x[i] = 0.0\n else:\n # no solution\n raise(Exception('no solution'))\n else:\n x[i] = acc / U[i,i]\n\n assert np.allclose(U.dot(x),z)\n\n return x\n\ndef test_lu():\n n_teste = 500\n np.random.seed(8)\n\n while(n_teste > 0):\n n_teste -= 1 \n n = np.random.randint(1,30)\n A = np.random.random((n,n))\n \n if(np.random.random() > 0.5):\n print('Not singular.')\n A[np.random.randint(0,n)] = np.random.uniform(0,100) * A[np.random.randint(0,n)]\n\n L, U, row_idx = lu_decomp(A)\n\n L = L[row_idx]\n U = U[row_idx]\n A = A[row_idx]\n\n assert np.allclose(L.dot(U).ravel(), A.ravel())\n \n print('LU decomposition Ok!')\n\ndef test_solve():\n np.random.seed(8)\n n_teste = 10\n while n_teste > 0:\n n_teste -= 1\n\n n = np.random.randint(1,100)\n A = np.random.random((n,n))\n b = np.random.random(n)\n\n #A[-1] = A[0]\n #b[-1] = b[0]\n \n ans_correct = np.linalg.solve(A,b)\n \n L,U,p = lu_decomp(A)\n ans = solve_lu(L,U,p,b)\n\n assert np.allclose(A.dot(ans), b)\n assert np.allclose(ans, ans_correct)\n \n print('Solve with LU Ok!')\n\nif __name__ == \"__main__\":\n test_lu()\n test_solve()\n\n \n \n\n\n\n" ]

[ [ "numpy.linalg.solve", "numpy.random.random", "numpy.allclose", "numpy.random.seed", "numpy.isclose", "numpy.eye", "numpy.random.uniform", "numpy.zeros", "numpy.random.randint" ] ]

kunalvats/featuretools

[ "25d8a36b7d636546161122095f5d6ca793a0b974" ]

[ "featuretools/computational_backends/pandas_backend.py" ]

[ "import cProfile\nimport logging\nimport os\nimport pstats\nimport sys\nimport warnings\nfrom datetime import datetime\n\nimport numpy as np\nimport pandas as pd\nimport pandas.api.types as pdtypes\nfrom future import standard_library\n\nfrom .base_backend import ComputationalBackend\nfrom .feature_tree import FeatureTree\n\nfrom featuretools import variable_types\nfrom featuretools.entityset.relationship import Relationship\nfrom featuretools.exceptions import UnknownFeature\nfrom featuretools.primitives import (\n AggregationPrimitive,\n DirectFeature,\n IdentityFeature,\n TransformPrimitive\n)\nfrom featuretools.utils.gen_utils import make_tqdm_iterator\n\nstandard_library.install_aliases()\nwarnings.simplefilter('ignore', np.RankWarning)\nwarnings.simplefilter(\"ignore\", category=RuntimeWarning)\nlogger = logging.getLogger('featuretools.computational_backend')\nROOT_DIR = os.path.expanduser(\"~\")\n\n\nclass PandasBackend(ComputationalBackend):\n\n def __init__(self, entityset, features):\n assert len(set(f.entity.id for f in features)) == 1, \\\n \"Features must all be defined on the same entity\"\n\n self.entityset = entityset\n self.target_eid = features[0].entity.id\n self.features = features\n self.feature_tree = FeatureTree(entityset, features)\n\n def __sizeof__(self):\n return self.entityset.__sizeof__()\n\n def calculate_all_features(self, instance_ids, time_last,\n training_window=None, profile=False,\n precalculated_features=None, ignored=None,\n verbose=False):\n \"\"\"\n Given a list of instance ids and features with a shared time window,\n generate and return a mapping of instance -> feature values.\n\n Args:\n instance_ids (list): List of instance id for which to build features.\n\n time_last (pd.Timestamp): Last allowed time. Data from exactly this\n time not allowed.\n\n training_window (Timedelta, optional): Data older than\n time_last by more than this will be ignored.\n\n profile (bool): Enable profiler if True.\n\n verbose (bool): Print output progress if True.\n\n Returns:\n pd.DataFrame : Pandas DataFrame of calculated feature values.\n Indexed by instance_ids. Columns in same order as features\n passed in.\n\n \"\"\"\n assert len(instance_ids) > 0, \"0 instance ids provided\"\n self.instance_ids = instance_ids\n\n self.time_last = time_last\n if self.time_last is None:\n self.time_last = datetime.now()\n\n # For debugging\n if profile:\n pr = cProfile.Profile()\n pr.enable()\n\n if precalculated_features is None:\n precalculated_features = {}\n # Access the index to get the filtered data we need\n target_entity = self.entityset[self.target_eid]\n if ignored:\n # TODO: Just want to remove entities if don't have any (sub)features defined\n # on them anymore, rather than recreating\n ordered_entities = FeatureTree(self.entityset, self.features, ignored=ignored).ordered_entities\n else:\n ordered_entities = self.feature_tree.ordered_entities\n\n necessary_columns = self.feature_tree.necessary_columns\n eframes_by_filter = \\\n self.entityset.get_pandas_data_slice(filter_entity_ids=ordered_entities,\n index_eid=self.target_eid,\n instances=instance_ids,\n entity_columns=necessary_columns,\n time_last=time_last,\n training_window=training_window,\n verbose=verbose)\n large_eframes_by_filter = None\n if any([f.uses_full_entity for f in self.feature_tree.all_features]):\n large_necessary_columns = self.feature_tree.necessary_columns_for_all_values_features\n large_eframes_by_filter = \\\n self.entityset.get_pandas_data_slice(filter_entity_ids=ordered_entities,\n index_eid=self.target_eid,\n instances=None,\n entity_columns=large_necessary_columns,\n time_last=time_last,\n training_window=training_window,\n verbose=verbose)\n\n # Handle an empty time slice by returning a dataframe with defaults\n if eframes_by_filter is None:\n return self.generate_default_df(instance_ids=instance_ids)\n\n finished_entity_ids = []\n # Populate entity_frames with precalculated features\n if len(precalculated_features) > 0:\n for entity_id, precalc_feature_values in precalculated_features.items():\n if entity_id in eframes_by_filter:\n frame = eframes_by_filter[entity_id][entity_id]\n eframes_by_filter[entity_id][entity_id] = pd.merge(frame,\n precalc_feature_values,\n left_index=True,\n right_index=True)\n else:\n # Only features we're taking from this entity\n # are precomputed\n # Make sure the id variable is a column as well as an index\n entity_id_var = self.entityset[entity_id].index\n precalc_feature_values[entity_id_var] = precalc_feature_values.index.values\n eframes_by_filter[entity_id] = {entity_id: precalc_feature_values}\n finished_entity_ids.append(entity_id)\n\n # Iterate over the top-level entities (filter entities) in sorted order\n # and calculate all relevant features under each one.\n if verbose:\n total_groups_to_compute = sum(len(group)\n for group in self.feature_tree.ordered_feature_groups.values())\n\n pbar = make_tqdm_iterator(total=total_groups_to_compute,\n desc=\"Computing features\",\n unit=\"feature group\")\n if verbose:\n pbar.update(0)\n\n for filter_eid in ordered_entities:\n entity_frames = eframes_by_filter[filter_eid]\n large_entity_frames = None\n if large_eframes_by_filter is not None:\n large_entity_frames = large_eframes_by_filter[filter_eid]\n\n # update the current set of entity frames with the computed features\n # from previously finished entities\n for eid in finished_entity_ids:\n # only include this frame if it's not from a descendent entity:\n # descendent entity frames will have to be re-calculated.\n # TODO: this check might not be necessary, depending on our\n # constraints\n if not self.entityset.find_backward_path(start_entity_id=filter_eid,\n goal_entity_id=eid):\n entity_frames[eid] = eframes_by_filter[eid][eid]\n # TODO: look this over again\n # precalculated features will only be placed in entity_frames,\n # and it's possible that that they are the only features computed\n # for an entity. In this case, the entity won't be present in\n # large_eframes_by_filter. The relevant lines that this case passes\n # through are 136-143\n if (large_eframes_by_filter is not None and\n eid in large_eframes_by_filter and eid in large_eframes_by_filter[eid]):\n large_entity_frames[eid] = large_eframes_by_filter[eid][eid]\n\n if filter_eid in self.feature_tree.ordered_feature_groups:\n for group in self.feature_tree.ordered_feature_groups[filter_eid]:\n if verbose:\n pbar.set_postfix({'running': 0})\n\n test_feature = group[0]\n entity_id = test_feature.entity.id\n\n input_frames_type = self.feature_tree.input_frames_type(test_feature)\n\n input_frames = large_entity_frames\n if input_frames_type == \"subset_entity_frames\":\n input_frames = entity_frames\n\n handler = self._feature_type_handler(test_feature)\n result_frame = handler(group, input_frames)\n\n output_frames_type = self.feature_tree.output_frames_type(test_feature)\n if output_frames_type in ['full_and_subset_entity_frames', 'subset_entity_frames']:\n index = entity_frames[entity_id].index\n # If result_frame came from a uses_full_entity feature,\n # and the input was large_entity_frames,\n # then it's possible it doesn't contain some of the features\n # in the output entity_frames\n # We thus need to concatenate the existing frame with the result frame,\n # making sure not to duplicate any columns\n _result_frame = result_frame.reindex(index)\n cols_to_keep = [c for c in _result_frame.columns\n if c not in entity_frames[entity_id].columns]\n entity_frames[entity_id] = pd.concat([entity_frames[entity_id],\n _result_frame[cols_to_keep]],\n axis=1)\n\n if output_frames_type in ['full_and_subset_entity_frames', 'full_entity_frames']:\n index = large_entity_frames[entity_id].index\n _result_frame = result_frame.reindex(index)\n cols_to_keep = [c for c in _result_frame.columns\n if c not in large_entity_frames[entity_id].columns]\n large_entity_frames[entity_id] = pd.concat([large_entity_frames[entity_id],\n _result_frame[cols_to_keep]],\n axis=1)\n\n if verbose:\n pbar.update(1)\n\n finished_entity_ids.append(filter_eid)\n\n if verbose:\n pbar.set_postfix({'running': 0})\n pbar.refresh()\n sys.stdout.flush()\n pbar.close()\n\n # debugging\n if profile:\n pr.disable()\n prof_folder_path = os.path.join(ROOT_DIR, 'prof')\n if not os.path.exists(prof_folder_path):\n os.mkdir(prof_folder_path)\n with open(os.path.join(prof_folder_path, 'inst-%s.log' %\n list(instance_ids)[0]), 'w') as f:\n pstats.Stats(pr, stream=f).strip_dirs().sort_stats(\"cumulative\", \"tottime\").print_stats()\n\n df = eframes_by_filter[self.target_eid][self.target_eid]\n\n # fill in empty rows with default values\n missing_ids = [i for i in instance_ids if i not in\n df[target_entity.index]]\n if missing_ids:\n default_df = self.generate_default_df(instance_ids=missing_ids,\n extra_columns=df.columns)\n df = df.append(default_df, sort=True)\n\n df.index.name = self.entityset[self.target_eid].index\n return df[[feat.get_name() for feat in self.features]]\n\n def generate_default_df(self, instance_ids, extra_columns=None):\n index_name = self.features[0].entity.index\n default_row = [f.default_value for f in self.features]\n default_cols = [f.get_name() for f in self.features]\n default_matrix = [default_row] * len(instance_ids)\n default_df = pd.DataFrame(default_matrix,\n columns=default_cols,\n index=instance_ids)\n default_df.index.name = index_name\n if extra_columns is not None:\n for c in extra_columns:\n if c not in default_df.columns:\n default_df[c] = [np.nan] * len(instance_ids)\n return default_df\n\n def _feature_type_handler(self, f):\n if isinstance(f, TransformPrimitive):\n return self._calculate_transform_features\n elif isinstance(f, DirectFeature):\n return self._calculate_direct_features\n elif isinstance(f, AggregationPrimitive):\n return self._calculate_agg_features\n elif isinstance(f, IdentityFeature):\n return self._calculate_identity_features\n else:\n raise UnknownFeature(u\"{} feature unknown\".format(f.__class__))\n\n def _calculate_identity_features(self, features, entity_frames):\n entity_id = features[0].entity.id\n assert (entity_id in entity_frames and\n features[0].get_name() in entity_frames[entity_id].columns)\n return entity_frames[entity_id]\n\n def _calculate_transform_features(self, features, entity_frames):\n entity_id = features[0].entity.id\n assert len(set([f.entity.id for f in features])) == 1, \\\n \"features must share base entity\"\n assert entity_id in entity_frames\n\n frame = entity_frames[entity_id]\n for f in features:\n # handle when no data\n if frame.shape[0] == 0:\n set_default_column(frame, f)\n continue\n\n # collect only the variables we need for this transformation\n variable_data = [frame[bf.get_name()].values\n for bf in f.base_features]\n\n feature_func = f.get_function()\n # apply the function to the relevant dataframe slice and add the\n # feature row to the results dataframe.\n if f.uses_calc_time:\n values = feature_func(*variable_data, time=self.time_last)\n else:\n values = feature_func(*variable_data)\n\n if isinstance(values, pd.Series):\n values = values.values\n frame[f.get_name()] = list(values)\n return frame\n\n def _calculate_direct_features(self, features, entity_frames):\n entity_id = features[0].entity.id\n parent_entity_id = features[0].parent_entity.id\n\n assert entity_id in entity_frames and parent_entity_id in entity_frames\n\n path = self.entityset.find_forward_path(entity_id, parent_entity_id)\n assert len(path) == 1, \\\n \"Error calculating DirectFeatures, len(path) > 1\"\n\n parent_df = entity_frames[parent_entity_id]\n child_df = entity_frames[entity_id]\n merge_var = path[0].child_variable.id\n\n # generate a mapping of old column names (in the parent entity) to\n # new column names (in the child entity) for the merge\n col_map = {path[0].parent_variable.id: merge_var}\n index_as_feature = None\n for f in features:\n if f.base_features[0].get_name() == path[0].parent_variable.id:\n index_as_feature = f\n # Sometimes entityset._add_multigenerational_links adds link variables\n # that would ordinarily get calculated as direct features,\n # so we make sure not to attempt to calculate again\n if f.get_name() in child_df.columns:\n continue\n col_map[f.base_features[0].get_name()] = f.get_name()\n\n # merge the identity feature from the parent entity into the child\n merge_df = parent_df[list(col_map.keys())].rename(columns=col_map)\n if index_as_feature is not None:\n merge_df.set_index(index_as_feature.get_name(), inplace=True,\n drop=False)\n else:\n merge_df.set_index(merge_var, inplace=True)\n\n new_df = pd.merge(left=child_df, right=merge_df,\n left_on=merge_var, right_index=True,\n how='left')\n\n return new_df\n\n def _calculate_agg_features(self, features, entity_frames):\n test_feature = features[0]\n entity = test_feature.entity\n child_entity = test_feature.base_features[0].entity\n\n assert entity.id in entity_frames and child_entity.id in entity_frames\n\n frame = entity_frames[entity.id]\n base_frame = entity_frames[child_entity.id]\n # Sometimes approximate features get computed in a previous filter frame\n # and put in the current one dynamically,\n # so there may be existing features here\n features = [f for f in features if f.get_name()\n not in frame.columns]\n if not len(features):\n return frame\n\n # handle where clause for all functions below\n where = test_feature.where\n if where is not None:\n base_frame = base_frame[base_frame[where.get_name()]]\n\n relationship_path = self.entityset.find_backward_path(entity.id,\n child_entity.id)\n\n groupby_var = Relationship._get_link_variable_name(relationship_path)\n\n # if the use_previous property exists on this feature, include only the\n # instances from the child entity included in that Timedelta\n use_previous = test_feature.use_previous\n if use_previous and not base_frame.empty:\n # Filter by use_previous values\n time_last = self.time_last\n if use_previous.is_absolute():\n time_first = time_last - use_previous\n ti = child_entity.time_index\n if ti is not None:\n base_frame = base_frame[base_frame[ti] >= time_first]\n else:\n n = use_previous.value\n\n def last_n(df):\n return df.iloc[-n:]\n\n base_frame = base_frame.groupby(groupby_var, observed=True, sort=False).apply(last_n)\n\n to_agg = {}\n agg_rename = {}\n to_apply = set()\n # apply multivariable and time-dependent features as we find them, and\n # save aggregable features for later\n for f in features:\n if _can_agg(f):\n variable_id = f.base_features[0].get_name()\n\n if variable_id not in to_agg:\n to_agg[variable_id] = []\n\n func = f.get_function()\n funcname = func\n if callable(func):\n funcname = func.__name__\n\n to_agg[variable_id].append(func)\n # this is used below to rename columns that pandas names for us\n agg_rename[u\"{}-{}\".format(variable_id, funcname)] = f.get_name()\n continue\n\n to_apply.add(f)\n\n # Apply the non-aggregable functions generate a new dataframe, and merge\n # it with the existing one\n if len(to_apply):\n wrap = agg_wrapper(to_apply, self.time_last)\n # groupby_var can be both the name of the index and a column,\n # to silence pandas warning about ambiguity we explicitly pass\n # the column (in actuality grouping by both index and group would\n # work)\n to_merge = base_frame.groupby(base_frame[groupby_var], observed=True, sort=False).apply(wrap)\n\n to_merge.reset_index(1, drop=True, inplace=True)\n frame = pd.merge(left=frame, right=to_merge,\n left_index=True,\n right_index=True, how='left')\n\n # Apply the aggregate functions to generate a new dataframe, and merge\n # it with the existing one\n if len(to_agg):\n # groupby_var can be both the name of the index and a column,\n # to silence pandas warning about ambiguity we explicitly pass\n # the column (in actuality grouping by both index and group would\n # work)\n to_merge = base_frame.groupby(base_frame[groupby_var],\n observed=True, sort=False).agg(to_agg)\n # rename columns to the correct feature names\n to_merge.columns = [agg_rename[\"-\".join(x)] for x in to_merge.columns.ravel()]\n to_merge = to_merge[list(agg_rename.values())]\n\n # workaround for pandas bug where categories are in the wrong order\n # see: https://github.com/pandas-dev/pandas/issues/22501\n if pdtypes.is_categorical_dtype(frame.index):\n categories = pdtypes.CategoricalDtype(categories=frame.index.categories)\n to_merge.index = to_merge.index.astype(object).astype(categories)\n\n frame = pd.merge(left=frame, right=to_merge,\n left_index=True, right_index=True, how='left')\n\n # Handle default values\n # 1. handle non scalar default values\n iterfeats = [f for f in features\n if hasattr(f.default_value, '__iter__')]\n for f in iterfeats:\n nulls = pd.isnull(frame[f.get_name()])\n for ni in nulls[nulls].index:\n frame.at[ni, f.get_name()] = f.default_value\n\n # 2. handle scalars default values\n fillna_dict = {f.get_name(): f.default_value for f in features\n if f not in iterfeats}\n frame.fillna(fillna_dict, inplace=True)\n\n # convert boolean dtypes to floats as appropriate\n # pandas behavior: https://github.com/pydata/pandas/issues/3752\n for f in features:\n if (not f.expanding and\n f.variable_type == variable_types.Numeric and\n frame[f.get_name()].dtype.name in ['object', 'bool']):\n frame[f.get_name()] = frame[f.get_name()].astype(float)\n\n return frame\n\n\ndef _can_agg(feature):\n assert isinstance(feature, AggregationPrimitive)\n base_features = feature.base_features\n if feature.where is not None:\n base_features = [bf.get_name() for bf in base_features\n if bf.get_name() != feature.where.get_name()]\n\n if feature.uses_calc_time:\n return False\n\n return len(base_features) == 1 and not feature.expanding\n\n\ndef agg_wrapper(feats, time_last):\n def wrap(df):\n d = {}\n for f in feats:\n func = f.get_function()\n variable_ids = [bf.get_name() for bf in f.base_features]\n args = [df[v] for v in variable_ids]\n\n if f.uses_calc_time:\n d[f.get_name()] = [func(*args, time=time_last)]\n else:\n d[f.get_name()] = [func(*args)]\n\n return pd.DataFrame(d)\n return wrap\n\n\ndef set_default_column(frame, f):\n default = f.default_value\n if hasattr(default, '__iter__'):\n length = frame.shape[0]\n default = [f.default_value] * length\n frame[f.get_name()] = default\n" ]

[ [ "pandas.api.types.is_categorical_dtype", "pandas.merge", "pandas.concat", "pandas.api.types.CategoricalDtype", "pandas.DataFrame" ] ]

uniomni/PyRate

[ "f77ad6e7fd90f3c0eb255bd553d4666b5db40bcf" ]

[ "tests/test_refpixel.py" ]

[ "# This Python module is part of the PyRate software package.\n#\n# Copyright 2020 Geoscience Australia\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"\nThis Python module contains tests for the refpixel.py PyRate module.\n\"\"\"\nimport copy\nimport shutil\nfrom subprocess import check_call, run\nfrom pathlib import Path\nimport pytest\nfrom numpy import nan, mean, std, isnan\n\nimport pyrate.core.refpixel\nfrom pyrate.core import config as cf\nfrom pyrate.core.refpixel import ref_pixel, _step, RefPixelError\nfrom pyrate.core import shared, ifgconstants as ifc\n\nfrom pyrate import process\nfrom pyrate.configuration import Configuration\nfrom tests.common import TEST_CONF_ROIPAC\nfrom tests.common import small_data_setup, MockIfg, copy_small_ifg_file_list, \\\n copy_and_setup_small_data, manipulate_test_conf, assert_two_dirs_equal, PYTHON3P6\n\n\n# TODO: figure out how editing resource.setrlimit fixes the error\n# to fix the open to many files error\n# https://stackoverflow.com/questions/18280612/ioerror-errno-24-too-many-open-files\n\n# default testing values\nREFNX = 5\nREFNY = 7\nMIN_FRAC = 0.7\nCHIPSIZE = 3\nPARALLEL = False\n\n\nclass TestReferencePixelInputTests:\n '''\n Verifies error checking capabilities of the reference pixel function\n '''\n\n @classmethod\n def setup_method(cls):\n cls.ifgs = small_data_setup()\n cls.params = cf.get_config_params(TEST_CONF_ROIPAC)\n cls.params[cf.REFNX] = REFNX\n cls.params[cf.REFNY] = REFNY\n cls.params[cf.REF_CHIP_SIZE] = CHIPSIZE\n cls.params[cf.REF_MIN_FRAC] = MIN_FRAC\n cls.params[cf.PARALLEL] = PARALLEL\n\n def test_missing_chipsize(self):\n self.params[cf.REF_CHIP_SIZE] = None\n with pytest.raises(cf.ConfigException):\n ref_pixel(self.ifgs, self.params)\n\n def test_chipsize_valid(self):\n for illegal in [0, -1, -15, 1, 2, self.ifgs[0].ncols+1, 4, 6, 10, 20]:\n self.params[cf.REF_CHIP_SIZE] = illegal\n with pytest.raises(RefPixelError):\n ref_pixel(self.ifgs, self.params)\n\n def test_minimum_fraction_missing(self):\n self.params[cf.REF_MIN_FRAC] = None\n with pytest.raises(cf.ConfigException):\n ref_pixel(self.ifgs, self.params)\n\n def test_minimum_fraction_threshold(self):\n for illegal in [-0.1, 1.1, 1.000001, -0.0000001]:\n self.params[cf.REF_MIN_FRAC] = illegal\n with pytest.raises(RefPixelError):\n ref_pixel(self.ifgs, self.params)\n\n def test_search_windows(self):\n # 45 is max # cells a width 3 sliding window can iterate over\n for illegal in [-5, -1, 0, 46, 50, 100]:\n self.params[cf.REFNX] = illegal\n with pytest.raises(RefPixelError):\n ref_pixel(self.ifgs, self.params)\n\n # 40 is max # cells a width 3 sliding window can iterate over\n for illegal in [-5, -1, 0, 71, 85, 100]:\n self.params[cf.REFNY] = illegal\n with pytest.raises(RefPixelError):\n ref_pixel(self.ifgs, self.params)\n\n def test_missing_search_windows(self):\n self.params[cf.REFNX] = None\n with pytest.raises(cf.ConfigException):\n ref_pixel(self.ifgs, self.params)\n\n self.params[cf.REFNX] = REFNX\n self.params[cf.REFNY] = None\n\n with pytest.raises(cf.ConfigException):\n ref_pixel(self.ifgs, self.params)\n\n\nclass TestReferencePixelTests:\n \"\"\"\n Tests reference pixel search\n \"\"\"\n\n @classmethod\n def setup_method(cls):\n cls.params = cf.get_config_params(TEST_CONF_ROIPAC)\n cls.params[cf.OUT_DIR], cls.ifgs = copy_and_setup_small_data()\n cls.params[cf.REFNX] = REFNX\n cls.params[cf.REFNY] = REFNY\n cls.params[cf.REF_CHIP_SIZE] = CHIPSIZE\n cls.params[cf.REF_MIN_FRAC] = MIN_FRAC\n cls.params[cf.PARALLEL] = PARALLEL\n\n def test_all_below_threshold_exception(self):\n # test failure when no valid stacks in dataset\n\n # rig mock data to be below threshold\n mock_ifgs = [MockIfg(i, 6, 7) for i in self.ifgs]\n for m in mock_ifgs:\n m.phase_data[:1] = nan\n m.phase_data[1:5] = 0.1\n m.phase_data[5:] = nan\n\n self.params[cf.REFNX] = 2\n self.params[cf.REFNY] = 2\n self.params[cf.REF_CHIP_SIZE] = CHIPSIZE\n self.params[cf.REF_MIN_FRAC] = MIN_FRAC\n self.params[cf.PARALLEL] = PARALLEL\n with pytest.raises(ValueError):\n ref_pixel(mock_ifgs, self.params)\n\n def test_refnxy_step_1(self):\n # test step of 1 for refnx|y gets the reference pixel for axis centre\n mock_ifgs = [MockIfg(i, 47, 72) for i in self.ifgs]\n for m in mock_ifgs:\n m.phase_data[:1] = 0.2\n m.phase_data[1:5] = 0.1\n m.phase_data[5:] = 0.3\n exp_refpx = (1, 1)\n self.params[cf.REFNX] = 1\n self.params[cf.REFNY] = 1\n self.params[cf.REF_CHIP_SIZE] = CHIPSIZE\n self.params[cf.REF_MIN_FRAC] = MIN_FRAC\n self.params[cf.PARALLEL] = PARALLEL\n res = ref_pixel(mock_ifgs, self.params)\n assert exp_refpx == res\n\n def test_large_window(self):\n # 5x5 view over a 5x5 ifg with 1 window/ref pix search\n chps = 5\n mockifgs = [MockIfg(i, chps, chps) for i in self.ifgs]\n self.params[cf.REFNX] = 1\n self.params[cf.REFNY] = 1\n self.params[cf.REF_CHIP_SIZE] = chps\n self.params[cf.REF_MIN_FRAC] = MIN_FRAC\n self.params[cf.PARALLEL] = PARALLEL\n res = ref_pixel(mockifgs, self.params)\n assert (2, 2) == res\n\n def test_step(self):\n # test different search windows to verify x/y step calculation\n\n # convenience testing function\n def assert_equal(actual, expected):\n for a, e in zip(actual, expected):\n assert a == e\n\n # start with simple corner only test\n width = 47\n radius = 2\n refnx = 2\n exp = [2, 25, 44]\n act = _step(width, refnx, radius)\n assert_equal(act, exp)\n\n # test with 3 windows\n refnx = 3\n exp = [2, 17, 32]\n act = _step(width, refnx, radius)\n assert_equal(act, exp)\n\n # test 4 search windows\n refnx = 4\n exp = [2, 13, 24, 35]\n act = _step(width, refnx, radius)\n assert_equal(act, exp)\n\n def test_ref_pixel(self):\n exp_refpx = (2, 25)\n self.params[cf.REFNX] = 2\n self.params[cf.REFNY] = 2\n self.params[cf.REF_CHIP_SIZE] = 5\n self.params[cf.REF_MIN_FRAC] = MIN_FRAC\n self.params[cf.PARALLEL] = PARALLEL\n res = ref_pixel(self.ifgs, self.params)\n assert res == exp_refpx\n\n # Invalidate first data stack, get new refpix coods & retest\n for i in self.ifgs:\n i.phase_data[:30, :50] = nan\n\n exp_refpx = (38, 2)\n res = ref_pixel(self.ifgs, self.params)\n assert res == exp_refpx\n\n\ndef _expected_ref_pixel(ifgs, cs):\n \"\"\"Helper function for finding reference pixel when refnx/y=2\"\"\"\n\n # calculate expected data\n data = [i.phase_data for i in ifgs] # len 17 list of arrays\n ul = [i[:cs, :cs] for i in data] # upper left corner stack\n ur = [i[:cs, -cs:] for i in data]\n ll = [i[-cs:, :cs] for i in data]\n lr = [i[-cs:, -cs:] for i in data]\n\n ulm = mean([std(i[~isnan(i)]) for i in ul]) # mean std of all the layers\n urm = mean([std(i[~isnan(i)]) for i in ur])\n llm = mean([std(i[~isnan(i)]) for i in ll])\n lrm = mean([std(i[~isnan(i)]) for i in lr])\n assert isnan([ulm, urm, llm, lrm]).any() is False\n\n # coords of the smallest mean is the result\n mn = [ulm, urm, llm, lrm]\n\n\nclass TestLegacyEqualityTest:\n\n @classmethod\n def setup_method(cls):\n cls.params = cf.get_config_params(TEST_CONF_ROIPAC)\n cls.params[cf.PARALLEL] = 0\n cls.params[cf.OUT_DIR], cls.ifg_paths = copy_small_ifg_file_list()\n conf_file = Path(cls.params[cf.OUT_DIR], 'conf_file.conf')\n cf.write_config_file(params=cls.params, output_conf_file=conf_file)\n cls.params = Configuration(conf_file).__dict__\n cls.params_alt_ref_frac = copy.copy(cls.params)\n cls.params_alt_ref_frac[cf.REF_MIN_FRAC] = 0.5\n cls.params_all_2s = copy.copy(cls.params)\n cls.params_all_2s[cf.REFNX] = 2\n cls.params_all_2s[cf.REFNY] = 2\n cls.params_chipsize_15 = copy.copy(cls.params_all_2s)\n cls.params_chipsize_15[cf.REF_CHIP_SIZE] = 15\n cls.params_all_1s = copy.copy(cls.params)\n cls.params_all_1s[cf.REFNX] = 1\n cls.params_all_1s[cf.REFNY] = 1\n cls.params_all_1s[cf.REF_MIN_FRAC] = 0.7\n\n for p, q in zip(cls.params[cf.INTERFEROGRAM_FILES], cls.ifg_paths): # hack\n p.sampled_path = q\n p.tmp_sampled_path = q\n\n @classmethod\n def teardown_method(cls):\n shutil.rmtree(cls.params[cf.OUT_DIR])\n\n def test_small_test_data_ref_pixel_lat_lon_provided(self):\n self.params[cf.REFX], self.params[cf.REFY] = 150.941666654, -34.218333314\n refx, refy = pyrate.core.refpixel.ref_pixel_calc_wrapper(self.params)\n assert refx == 38\n assert refy == 58\n assert 0.8 == pytest.approx(self.params[cf.REF_MIN_FRAC])\n\n def test_small_test_data_ref_pixel(self):\n refx, refy = pyrate.core.refpixel.ref_pixel_calc_wrapper(self.params)\n assert refx == 38\n assert refy == 58\n assert 0.8 == pytest.approx(self.params[cf.REF_MIN_FRAC])\n\n def test_small_test_data_ref_chipsize_15(self):\n\n refx, refy = pyrate.core.refpixel.ref_pixel_calc_wrapper(self.params_chipsize_15)\n assert refx == 7\n assert refy == 7\n assert 0.5 == pytest.approx(self.params_alt_ref_frac[cf.REF_MIN_FRAC])\n\n def test_metadata(self):\n refx, refy = pyrate.core.refpixel.ref_pixel_calc_wrapper(self.params_chipsize_15)\n for i in self.ifg_paths:\n ifg = shared.Ifg(i)\n ifg.open(readonly=True)\n md = ifg.meta_data\n for k, v in zip([ifc.PYRATE_REFPIX_X, ifc.PYRATE_REFPIX_Y, ifc.PYRATE_REFPIX_LAT,\n ifc.PYRATE_REFPIX_LON, ifc.PYRATE_MEAN_REF_AREA, ifc.PYRATE_STDDEV_REF_AREA],\n [str(refx), str(refy), 0, 0, 0, 0]):\n assert k in md # metadata present\n # assert values\n ifg.close()\n\n def test_small_test_data_ref_all_1(self):\n refx, refy = pyrate.core.refpixel.ref_pixel_calc_wrapper(self.params_all_1s)\n assert 0.7 == pytest.approx(self.params_all_1s[cf.REF_MIN_FRAC])\n assert 1 == self.params_all_1s[cf.REFNX]\n assert 1 == self.params_all_1s[cf.REFNY]\n assert refx == 2\n assert refy == 2\n\n\nclass TestLegacyEqualityTestMultiprocessParallel:\n\n @classmethod\n def setup_method(cls):\n cls.params = cf.get_config_params(TEST_CONF_ROIPAC)\n cls.params[cf.PARALLEL] = 1\n cls.params[cf.OUT_DIR], cls.ifg_paths = copy_small_ifg_file_list()\n conf_file = Path(cls.params[cf.OUT_DIR], 'conf_file.conf')\n cf.write_config_file(params=cls.params, output_conf_file=conf_file)\n cls.params = Configuration(conf_file).__dict__\n cls.params_alt_ref_frac = copy.copy(cls.params)\n cls.params_alt_ref_frac[cf.REF_MIN_FRAC] = 0.5\n cls.params_all_2s = copy.copy(cls.params)\n cls.params_all_2s[cf.REFNX] = 2\n cls.params_all_2s[cf.REFNY] = 2\n cls.params_chipsize_15 = copy.copy(cls.params_all_2s)\n cls.params_chipsize_15[cf.REF_CHIP_SIZE] = 15\n cls.params_all_1s = copy.copy(cls.params)\n cls.params_all_1s[cf.REFNX] = 1\n cls.params_all_1s[cf.REFNY] = 1\n cls.params_all_1s[cf.REF_MIN_FRAC] = 0.7\n\n for p, q in zip(cls.params[cf.INTERFEROGRAM_FILES], cls.ifg_paths): # hack\n p.sampled_path = q\n p.tmp_sampled_path = q\n\n @classmethod\n def teardown_method(cls):\n shutil.rmtree(cls.params[cf.OUT_DIR])\n\n def test_small_test_data_ref_pixel(self):\n refx, refy = pyrate.core.refpixel.ref_pixel_calc_wrapper(self.params)\n assert refx == 38\n assert refy == 58\n assert 0.8 == pytest.approx(self.params[cf.REF_MIN_FRAC])\n\n def test_more_small_test_data_ref_pixel(self):\n\n refx, refy = pyrate.core.refpixel.ref_pixel_calc_wrapper(self.params_alt_ref_frac)\n assert refx == 38\n assert refy == 58\n assert 0.5 == pytest.approx(self.params_alt_ref_frac[cf.REF_MIN_FRAC])\n\n def test_small_test_data_ref_pixel_all_2(self):\n\n refx, refy = pyrate.core.refpixel.ref_pixel_calc_wrapper(self.params_all_2s)\n assert refx == 25\n assert refy == 2\n assert 0.5 == pytest.approx(self.params_alt_ref_frac[cf.REF_MIN_FRAC])\n\n def test_small_test_data_ref_chipsize_15(self):\n\n refx, refy = pyrate.core.refpixel.ref_pixel_calc_wrapper(self.params_chipsize_15)\n assert refx == 7\n assert refy == 7\n assert 0.5 == pytest.approx(self.params_alt_ref_frac[cf.REF_MIN_FRAC])\n\n def test_small_test_data_ref_all_1(self):\n\n refx, refy = pyrate.core.refpixel.ref_pixel_calc_wrapper(self.params_all_1s)\n\n assert 0.7 == pytest.approx(self.params_all_1s[cf.REF_MIN_FRAC])\n assert 1 == self.params_all_1s[cf.REFNX]\n assert 1 == self.params_all_1s[cf.REFNY]\n assert refx == 2\n assert refy == 2\n\n\[email protected]\[email protected](PYTHON3P6, reason='Skipped in python3p6')\ndef test_error_msg_refpixel_out_out_bounds(tempdir, gamma_conf):\n \"check correct latitude/longitude refpixel error is raised when specified refpixel is out of bounds\"\n for x, (refx, refy) in zip(['longitude', 'latitude', 'longitude and latitude'],\n [(150., -34.218333314), (150.941666654, -34.), (150, -34)]):\n _, out = _get_mlooked_files(gamma_conf, Path(tempdir()), refx=refx, refy=refy)\n msg = \"Supplied {} value is outside the bounds of the interferogram data\"\n assert msg.format(x) in out.stderr\n\n\[email protected]\[email protected](PYTHON3P6, reason='Skipped in python3p6')\ndef test_gamma_ref_pixel_search_vs_lat_lon(tempdir, gamma_conf):\n params_1, _ = _get_mlooked_files(gamma_conf, Path(tempdir()), refx=-1, refy=-1)\n params_2, _ = _get_mlooked_files(gamma_conf, Path(tempdir()), refx=150.941666654, refy=-34.218333314)\n assert_two_dirs_equal(params_1[cf.OUT_DIR], params_2[cf.OUT_DIR], f\"*{params_1[cf.IFG_CROP_OPT]}cr.tif\", 18)\n\n\ndef _get_mlooked_files(gamma_conf, tdir, refx, refy):\n params = manipulate_test_conf(gamma_conf, tdir)\n params[cf.REFX] = refx\n params[cf.REFY] = refy\n output_conf_file = 'config.conf'\n output_conf = tdir.joinpath(output_conf_file)\n cf.write_config_file(params=params, output_conf_file=output_conf)\n check_call(f\"pyrate conv2tif -f {output_conf}\", shell=True)\n check_call(f\"pyrate prepifg -f {output_conf}\", shell=True)\n stdout = run(f\"pyrate process -f {output_conf}\", shell=True, capture_output=True, text=True)\n print(\"============================================\", stdout)\n return params, stdout\n" ]

[ [ "numpy.isnan" ] ]

svebk/py-faster-rcnn

[ "1d0c40c42930f8e89634c057a0ed902aace395bd" ]

[ "lib/fast_rcnn/config.py" ]

[ "# --------------------------------------------------------\n# Fast R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick\n# --------------------------------------------------------\n\n\"\"\"Fast R-CNN config system.\n\nThis file specifies default config options for Fast R-CNN. You should not\nchange values in this file. Instead, you should write a config file (in yaml)\nand use cfg_from_file(yaml_file) to load it and override the default options.\n\nMost tools in $ROOT/tools take a --cfg option to specify an override file.\n - See tools/{train,test}_net.py for example code that uses cfg_from_file()\n - See experiments/cfgs/*.yml for example YAML config override files\n\"\"\"\n\nimport os\nimport os.path as osp\nimport numpy as np\n# `pip install easydict` if you don't have it\nfrom easydict import EasyDict as edict\n\n__C = edict()\n# Consumers can get config by:\n# from fast_rcnn_config import cfg\ncfg = __C\n\n#\n# Training options\n#\n\n__C.TRAIN = edict()\n\n# Scales to use during training (can list multiple scales)\n# Each scale is the pixel size of an image's shortest side\n__C.TRAIN.SCALES = (600,)\n\n# Max pixel size of the longest side of a scaled input image\n__C.TRAIN.MAX_SIZE = 1000\n\n# Images to use per minibatch\n__C.TRAIN.IMS_PER_BATCH = 2\n\n# Minibatch size (number of regions of interest [ROIs])\n__C.TRAIN.BATCH_SIZE = 128\n\n# Fraction of minibatch that is labeled foreground (i.e. class > 0)\n__C.TRAIN.FG_FRACTION = 0.25\n\n# Overlap threshold for a ROI to be considered foreground (if >= FG_THRESH)\n__C.TRAIN.FG_THRESH = 0.5\n\n# Overlap threshold for a ROI to be considered background (class = 0 if\n# overlap in [LO, HI))\n__C.TRAIN.BG_THRESH_HI = 0.5\n__C.TRAIN.BG_THRESH_LO = 0.1\n\n# Use horizontally-flipped images during training?\n__C.TRAIN.USE_FLIPPED = True\n\n# Train bounding-box regressors\n__C.TRAIN.BBOX_REG = True\n\n# Overlap required between a ROI and ground-truth box in order for that ROI to\n# be used as a bounding-box regression training example\n__C.TRAIN.BBOX_THRESH = 0.5\n\n# Iterations between snapshots\n__C.TRAIN.SNAPSHOT_ITERS = 10000\n\n# solver.prototxt specifies the snapshot path prefix, this adds an optional\n# infix to yield the path: <prefix>[_<infix>]_iters_XYZ.caffemodel\n__C.TRAIN.SNAPSHOT_INFIX = ''\n\n# Use a prefetch thread in roi_data_layer.layer\n# So far I haven't found this useful; likely more engineering work is required\n__C.TRAIN.USE_PREFETCH = False\n\n# Normalize the targets (subtract empirical mean, divide by empirical stddev)\n__C.TRAIN.BBOX_NORMALIZE_TARGETS = True\n# Deprecated (inside weights)\n__C.TRAIN.BBOX_INSIDE_WEIGHTS = (1.0, 1.0, 1.0, 1.0)\n# Normalize the targets using \"precomputed\" (or made up) means and stdevs\n# (BBOX_NORMALIZE_TARGETS must also be True)\n__C.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED = False\n__C.TRAIN.BBOX_NORMALIZE_MEANS = (0.0, 0.0, 0.0, 0.0)\n__C.TRAIN.BBOX_NORMALIZE_STDS = (0.1, 0.1, 0.2, 0.2)\n\n# Train using these proposals\n__C.TRAIN.PROPOSAL_METHOD = 'selective_search'\n\n# Make minibatches from images that have similar aspect ratios (i.e. both\n# tall and thin or both short and wide) in order to avoid wasting computation\n# on zero-padding.\n__C.TRAIN.ASPECT_GROUPING = True\n\n# Use RPN to detect objects\n__C.TRAIN.HAS_RPN = False\n# IOU >= thresh: positive example\n__C.TRAIN.RPN_POSITIVE_OVERLAP = 0.7\n# IOU < thresh: negative example\n__C.TRAIN.RPN_NEGATIVE_OVERLAP = 0.3\n# If an anchor statisfied by positive and negative conditions set to negative\n__C.TRAIN.RPN_CLOBBER_POSITIVES = False\n# Max number of foreground examples\n__C.TRAIN.RPN_FG_FRACTION = 0.5\n# Total number of examples\n__C.TRAIN.RPN_BATCHSIZE = 256\n# NMS threshold used on RPN proposals\n__C.TRAIN.RPN_NMS_THRESH = 0.7\n# Number of top scoring boxes to keep before apply NMS to RPN proposals\n__C.TRAIN.RPN_PRE_NMS_TOP_N = 12000\n# Number of top scoring boxes to keep after applying NMS to RPN proposals\n__C.TRAIN.RPN_POST_NMS_TOP_N = 2000\n# Proposal height and width both need to be greater than RPN_MIN_SIZE (at orig image scale)\n__C.TRAIN.RPN_MIN_SIZE = 16\n# Deprecated (outside weights)\n__C.TRAIN.RPN_BBOX_INSIDE_WEIGHTS = (1.0, 1.0, 1.0, 1.0)\n# Give the positive RPN examples weight of p * 1 / {num positives}\n# and give negatives a weight of (1 - p)\n# Set to -1.0 to use uniform example weighting\n__C.TRAIN.RPN_POSITIVE_WEIGHT = -1.0\n\n\n#\n# Testing options\n#\n\n__C.TEST = edict()\n\n# Scales to use during testing (can list multiple scales)\n# Each scale is the pixel size of an image's shortest side\n__C.TEST.SCALES = (600,)\n\n# Max pixel size of the longest side of a scaled input image\n__C.TEST.MAX_SIZE = 1000\n\n# Overlap threshold used for non-maximum suppression (suppress boxes with\n# IoU >= this threshold)\n__C.TEST.NMS = 0.3\n\n# Experimental: treat the (K+1) units in the cls_score layer as linear\n# predictors (trained, eg, with one-vs-rest SVMs).\n__C.TEST.SVM = False\n\n# Test using bounding-box regressors\n__C.TEST.BBOX_REG = True\n\n# Propose boxes\n__C.TEST.HAS_RPN = False\n\n# Test using these proposals\n__C.TEST.PROPOSAL_METHOD = 'selective_search'\n\n## NMS threshold used on RPN proposals\n__C.TEST.RPN_NMS_THRESH = 0.7\n## Number of top scoring boxes to keep before apply NMS to RPN proposals\n__C.TEST.RPN_PRE_NMS_TOP_N = 6000\n## Number of top scoring boxes to keep after applying NMS to RPN proposals\n__C.TEST.RPN_POST_NMS_TOP_N = 300\n# Proposal height and width both need to be greater than RPN_MIN_SIZE (at orig image scale)\n__C.TEST.RPN_MIN_SIZE = 16\n\n\n#\n# MISC\n#\n\n# The mapping from image coordinates to feature map coordinates might cause\n# some boxes that are distinct in image space to become identical in feature\n# coordinates. If DEDUP_BOXES > 0, then DEDUP_BOXES is used as the scale factor\n# for identifying duplicate boxes.\n# 1/16 is correct for {Alex,Caffe}Net, VGG_CNN_M_1024, and VGG16\n__C.DEDUP_BOXES = 1./16.\n\n# Pixel mean values (BGR order) as a (1, 1, 3) array\n# We use the same pixel mean for all networks even though it's not exactly what\n# they were trained with\n__C.PIXEL_MEANS = np.array([[[102.9801, 115.9465, 122.7717]]])\n\n# For reproducibility\n__C.RNG_SEED = 3\n\n# A small number that's used many times\n__C.EPS = 1e-14\n\n# Root directory of project\n__C.ROOT_DIR = osp.abspath(osp.join(osp.dirname(__file__), '..', '..'))\n\n# Data directory\n__C.DATA_DIR = osp.abspath(osp.join(__C.ROOT_DIR, 'data'))\n\n# Model directory\n__C.MODELS_DIR = osp.abspath(osp.join(__C.ROOT_DIR, 'models'))\n\n# Name (or path to) the matlab executable\n__C.MATLAB = 'matlab'\n\n# Place outputs under an experiments directory\n__C.EXP_DIR = 'default'\n\n# Use GPU implementation of non-maximum suppression\n__C.USE_GPU_NMS = True\n\n# Default GPU device id\n__C.GPU_ID = 0\n\n\ndef get_output_dir(imdb, net):\n \"\"\"Return the directory where experimental artifacts are placed.\n\n A canonical path is built using the name from an imdb and a network\n (if not None).\n \"\"\"\n path = osp.abspath(osp.join(__C.ROOT_DIR, 'output', __C.EXP_DIR, imdb.name))\n if net is None:\n return path\n else:\n return osp.join(path, net.name)\n\ndef _merge_a_into_b(a, b):\n \"\"\"Merge config dictionary a into config dictionary b, clobbering the\n options in b whenever they are also specified in a.\n \"\"\"\n if type(a) is not edict:\n return\n\n for k, v in a.iteritems():\n # a must specify keys that are in b\n if not b.has_key(k):\n raise KeyError('{} is not a valid config key'.format(k))\n\n # the types must match, too\n old_type = type(b[k])\n if old_type is not type(v):\n if isinstance(b[k], np.ndarray):\n v = np.array(v, dtype=b[k].dtype)\n else:\n raise ValueError(('Type mismatch ({} vs. {}) '\n 'for config key: {}').format(type(b[k]),\n type(v), k))\n\n # recursively merge dicts\n if type(v) is edict:\n try:\n _merge_a_into_b(a[k], b[k])\n except:\n print('Error under config key: {}'.format(k))\n raise\n else:\n b[k] = v\n\ndef cfg_from_file(filename):\n \"\"\"Load a config file and merge it into the default options.\"\"\"\n import yaml\n with open(filename, 'r') as f:\n yaml_cfg = edict(yaml.load(f))\n\n _merge_a_into_b(yaml_cfg, __C)\n\ndef cfg_from_list(cfg_list):\n \"\"\"Set config keys via list (e.g., from command line).\"\"\"\n from ast import literal_eval\n assert len(cfg_list) % 2 == 0\n for k, v in zip(cfg_list[0::2], cfg_list[1::2]):\n key_list = k.split('.')\n d = __C\n for subkey in key_list[:-1]:\n assert d.has_key(subkey)\n d = d[subkey]\n subkey = key_list[-1]\n assert d.has_key(subkey)\n try:\n value = literal_eval(v)\n except:\n # handle the case when v is a string literal\n value = v\n assert type(value) == type(d[subkey]), \\\n 'type {} does not match original type {}'.format(\n type(value), type(d[subkey]))\n d[subkey] = value\n" ]

[ [ "numpy.array" ] ]

KentaroKutsukake/Integrating-multiple-materials-science-projects

[ "a6f09583718fc00431a3ce67d5fc6f026646f91c" ]

[ "codes/MIGraph/Encoders/CompoundEncoder.py" ]

[ "\n\"\"\"\nCompound encoder\nthis class returns vector information of a target smiles\n\"\"\"\n\nimport numpy as np\nfrom Config import Config\n\nCF=Config()\ncategoryEmbed=CF.categoryEmbed\n\n\n#compound encoder class\nclass CompEncoder:\n def __init__(self,CompDat,num):\n \"\"\"\n CompDat: CompDatabase class\n num: =CF.ID_COMPOUNDS (=3)\n \"\"\"\n self.CompDat=CompDat \n self.num=num\n \n #get embetting vector\n def getEVector(self,string):\n \"\"\"\n input: SMILES\n return :embedding vector\n \"\"\"\n num=self.num\n res=self.CompDat.getCompDesc(string)\n num=categoryEmbed(np.array([num])).array\n \n return np.concatenate([num,res],1).reshape(-1)\n " ]

[ [ "numpy.concatenate", "numpy.array" ] ]

broestls/pycuda-bw-test

[ "0ac9a377363bb99bc1b9e5dd42bbdd0bd6d697c3" ]

[ "bwt.py" ]

[ "import numpy as np\n\nimport pycuda.driver as cuda\nfrom pycuda.compiler import SourceModule\nfrom pycuda.tools import make_default_context, clear_context_caches\n\nimport glob\nimport sys\nimport os\nfrom datetime import datetime\nimport ctypes\nimport atexit\nimport argparse\nimport subprocess\nimport psutil\nimport itertools\n\nfrom signal import signal, SIGINT\nfrom sys import exit\nfrom multiprocessing import Process, Value, set_start_method, Pool, cpu_count, current_process\nfrom codetiming import Timer\nfrom utils import calc_bws, calc_gbs\n\nglobal cuda_devices\n\nparser = argparse.ArgumentParser(description=\"A program for simulating load on GPU memory and system bus\")\ngroup = parser.add_mutually_exclusive_group(required=True)\ngroup.add_argument('--single', type=int, help=\"Run with a N constant size array\")\ngroup.add_argument('--batch', action='store_true')\ngroup.add_argument('--hwinfo', type=int, help=\"Gets info for CUDA device with ID\")\nparser.add_argument('-d', '--num_devices', type=int, help=\"Number of CUDA devices to use\")\nparser.add_argument('-i', '--iterations', type=int, default=1, help=\"number of iterations to run\")\nparser.add_argument('-w', '--workers', type=int, default=4, help=\"number of workers to spawn\")\nparser.add_argument('-e', '--elements', type=int, default=4, help=\"number of numpy arrays to work on\")\nparser.add_argument('--debug', action='store_true')\nparser.add_argument('-n', '--name', type=str, help='name to use for the run')\nargs = parser.parse_args()\n\ndef get_hw_info(device_id):\n device = cuda.Device(device_id)\n return \"device_id: {}, bus_id: {}, name: {}, cuda_version: {}\".format(device_id, device.pci_bus_id(), device.name(), cuda.get_version())\n\ndef handler(signal_received, frame):\n print('Shutting down...')\n exit(0)\n\ndef np_to_hmem(src, dest):\n source = src.ctypes.data_as(ctypes.POINTER(ctypes.c_float))\n destination = dest.ctypes.data_as(ctypes.POINTER(ctypes.c_float))\n size = src.size * ctypes.sizeof(ctypes.c_float)\n ctypes.memmove(source,destination,size)\n\ndef load_single_array(mb_size):\n return np.random.randn(int(mb_size * (10**6)/4)).astype(np.float32)\n\ndef transfer_data(size):\n t1 = Timer(name=\"total_memcpy_time\", logger=None)\n t1.start()\n cuda.init()\n device = cuda.Device(0)\n context = device.make_context()\n dev_id = context.get_device().pci_bus_id()\n np_array = np.random.randn(int(size * (10**6)/4)).astype(np.float32)\n np_return = np.empty_like(np_array)\n mem_gpu = cuda.mem_alloc(np_array.nbytes)\n mem_host = cuda.register_host_memory(np_array)\n np_to_hmem(np_array,mem_host)\n t2 = Timer(name=\"hmem_to_dmem\", logger=None)\n t2.start()\n cuda.memcpy_htod(mem_gpu, mem_host)\n t2.stop()\n t3 = Timer(name=\"dmem_to_hmem\", logger=None)\n t3.start()\n return_data = np.empty_like(np_array)\n cuda.memcpy_dtoh(mem_host, mem_gpu)\n t3.stop()\n mem_host.base.unregister()\n mem_gpu.free()\n context.pop()\n context = None\n clear_context_caches()\n t1.stop()\n if(args.debug):\n print(\"{},{},{},{},{},{},{},{}\".format('htod-'+args.name+'-debug',args.single,format(t2.last, '.4f'),calc_gbs(size,t2.last),psutil.Process().cpu_num(),psutil.Process().pid,dev_id,current_process().name))\n print(\"{},{},{},{},{},{},{},{}\".format('dtoh-'+args.name+'-debug',args.single,format(t3.last, '.4f'),calc_gbs(size,t3.last),psutil.Process().cpu_num(),psutil.Process().pid,dev_id,current_process().name))\n return {'total_time':t1.last, 'htod': calc_gbs(size,t2.last), 'htod_time':t2.last, 'dtoh': calc_gbs(size,t3.last), 'dtoh_time':t3.last}\n\ndef devices_to_workers():\n cuda.init()\n global cuda_devices\n available_devices = args.num_cuda_devices\n for i in range(args.workers):\n cuda_devices[i] = 0\n\nif __name__ == \"__main__\":\n signal(SIGINT, handler)\n set_start_method('fork')\n np_list = [args.single for x in range(args.elements)]\n pool = Pool(processes=args.workers)\n for i in range(args.iterations):\n total_size = args.single * args.elements\n res = pool.map(transfer_data, np_list)\n hotd_bandwidth = sum([float(x['htod']) for x in res])/args.elements\n dtoh_bandwidth = sum([float(x['dtoh']) for x in res])/args.elements\n total_time = sum([float(x['total_time']) for x in res])\n htod_time = sum([float(x['htod_time']) for x in res])\n dtoh_time = sum([float(x['dtoh_time']) for x in res])\n print(\"{},{},{},{},{},{},{},{},{},{}\".format(args.name,args.single,format(total_time, '.4f'),format(hotd_bandwidth, '.4f'),format(htod_time, '.4f'),format(dtoh_bandwidth, '.4f'),format(dtoh_time, '.4f'),args.workers,'epoch-'+str(i),datetime.now().strftime(\"%H:%M:%S:%f\")))\n if args.hwinfo != None:\n print(get_hw_info(args.hwinfo))" ]

[ [ "numpy.empty_like" ] ]

marcoalsina/araucaria

[ "78039106ae27d3fdef9265503c33f33992199d8e" ]

[ "docs/build/html/xas/xas_ft-5.py" ]

[ "from numpy import arange, sin, pi\nfrom scipy.fftpack import fftfreq\nfrom araucaria.xas import ftwindow, xftf_kwin, xftr_kwin\nnfft = 2048 # number of points for FFT\nks = 0.05 # delta k (angstrom^-1)\nf1 = 0.5 # freq1 (angstrom)\nk = arange(0, 10, ks)\nwink = ftwindow(k, x_range=(0,10), dx1=0.5, win='sine')\nchi = 0.5*sin(2*pi*k*f1)\nchir = xftf_kwin(wink*chi, nfft=nfft, kstep=ks)\nfreq = fftfreq(nfft, ks)[:nfft//2]\nchiq = xftr_kwin(chir, nfft=nfft, kstep=ks)[:len(k)]\nprint(chiq.dtype)\n# complex128\n\n# plotting reverse FFT signal\nimport matplotlib.pyplot as plt\nfrom araucaria.plot import fig_xas_template\nfig, ax = fig_xas_template(panels='re', fig_pars={'kweight':0})\nline = ax[0].plot(freq, abs(chir))\nxlim = ax[0].set_xlim(0,2)\nxlab = ax[0].set_xlabel('$R/\\pi$ [$\\AA$]')\nline = ax[1].plot(k, chiq)\ntext = ax[1].set_xlabel(r'$q(\\AA^{-1})$')\ntext = ax[1].set_ylabel(r'$\\chi(q)$')\nfig.tight_layout()\nplt.show(block=False)\n" ]

[ [ "numpy.arange", "matplotlib.pyplot.show", "scipy.fftpack.fftfreq", "numpy.sin" ] ]

KirillDZR/supreme

[ "c296722599363bd0cbcce6877bd9de9b066cb74b" ]

[ "supreme/lib/klt/setup.py" ]

[ "from supreme._build import CExtension\n\ndef configuration(parent_package='', top_path=None):\n from numpy.distutils.misc_util import Configuration, get_numpy_include_dirs\n\n config = Configuration('klt', parent_package, top_path)\n\n config.ext_modules.append(CExtension('libklt_',\n ['convolve.c', 'error.c', 'pnmio.c',\n 'pyramid.c', 'selectGoodFeatures.c',\n 'storeFeatures.c', 'trackFeatures.c',\n 'klt.c', 'klt_util.c',\n 'writeFeatures.c'],\n path=config.local_path))\n\n config.add_data_dir('tests')\n\n return config\n" ]

[ [ "numpy.distutils.misc_util.Configuration" ] ]

davidarps/NeuroX

[ "591cabce7a317d2a1ff2b07e6a3b277250815454" ]

[ "neurox/interpretation/utils.py" ]

[ "import math\nimport numpy as np\n\nfrom imblearn.under_sampling import RandomUnderSampler\n\ndef isnotebook():\n \"\"\"\n Utility function to detect if the code being run is within a jupyter\n notebook. Useful to change progress indicators for example.\n\n Returns\n -------\n isnotebook : bool\n True if the function is being called inside a notebook, False otherwise.\n \"\"\"\n try:\n shell = get_ipython().__class__.__name__\n if shell == \"ZMQInteractiveShell\":\n return True # Jupyter notebook or qtconsole\n elif shell == \"TerminalInteractiveShell\":\n return False # Terminal running IPython\n else:\n return False # Other type (?)\n except NameError:\n return False # Probably standard Python interpreter\n\ndef get_progress_bar():\n \"\"\"\n Utility function to get a progress bar depending on the environment the code\n is running in. A normal text-based progress bar is returned in normal\n shells, and a notebook widget-based progress bar is returned in jupyter\n notebooks.\n\n Returns\n -------\n progressbar : function\n The appropriate progressbar from the tqdm library.\n\n \"\"\"\n if isnotebook():\n from tqdm import tqdm_notebook as progressbar\n else:\n from tqdm import tqdm as progressbar\n\n return progressbar\n\ndef batch_generator(X, y, batch_size=32):\n \"\"\"\n Generator function to generate batches of data for training/evaluation.\n\n This function takes two tensors representing the activations and labels\n respectively, and yields batches of parallel data. The last batch may\n contain fewer than ``batch_size`` elements.\n\n Parameters\n ----------\n X : numpy.ndarray\n Numpy Matrix of size [``NUM_TOKENS`` x ``NUM_NEURONS``]. Usually the\n output of ``interpretation.utils.create_tensors``\n y : numpy.ndarray\n Numpy Vector of size [``NUM_TOKENS``] with class labels for each input\n token. For classification, 0-indexed class labels for each input token\n are expected. For regression, a real value per input token is expected.\n Usually the output of ``interpretation.utils.create_tensors``\n batch_size : int, optional\n Number of samples to return in each call. Defaults to 32.\n\n Yields\n ------\n X_batch : numpy.ndarray\n Numpy Matrix of size [``batch_size`` x ``NUM_NEURONS``]. The final batch\n may have fewer elements than the requested ``batch_size``\n y_batch : numpy.ndarray\n Numpy Vector of size [``batch_size``]. The final batch may have fewer\n elements than the requested ``batch_size``\n \"\"\"\n start_idx = 0\n while start_idx < X.shape[0]:\n yield X[start_idx : start_idx + batch_size], y[\n start_idx : start_idx + batch_size\n ]\n start_idx = start_idx + batch_size\n\ndef tok2idx(tokens):\n \"\"\"\n Utility function to generate unique indices for a set of tokens.\n\n Parameters\n ----------\n tokens : list of lists\n List of sentences, where each sentence is a list of tokens. Usually\n returned from ``data.loader.load_data``\n\n Returns\n -------\n tok2idx_mapping : dict\n A dictionary with tokens as keys and a unique index for each token as\n values\n \"\"\"\n uniq_tokens = set().union(*tokens)\n return {p: idx for idx, p in enumerate(uniq_tokens)}\n\n\ndef idx2tok(srcidx):\n \"\"\"\n Utility function to an inverse mapping from a ``tok2idx`` mapping.\n\n Parameters\n ----------\n tok2idx_mapping : dict\n Token to index mapping, usually the output for\n ``interpretation.utils.tok2idx``.\n\n Returns\n -------\n idx2tok : dict\n A dictionary with unique indices as keys and their associated tokens as\n values\n \"\"\"\n return {v: k for k, v in srcidx.items()}\n\n\ndef count_target_words(tokens):\n \"\"\"\n Utility function to count the total number of tokens in a dataset.\n\n Parameters\n ----------\n tokens : list of lists\n List of sentences, where each sentence is a list of tokens. Usually\n returned from ``data.loader.load_data``\n\n Returns\n -------\n count : int\n Total number of tokens in the given ``tokens`` structure\n \"\"\"\n return sum([len(t) for t in tokens[\"target\"]])\n\n\ndef create_tensors(\n tokens, activations, task_specific_tag, mappings=None, task_type=\"classification\", binarized_tag = None, balance_data = False, dtype=None\n):\n \"\"\"\n Method to pre-process loaded datasets into tensors that can be used to train\n probes and perform analyis on. The input tokens are represented as list of\n sentences, where each sentence is a list of tokens. Each token also has\n an associated label. All tokens from all sentences are flattened into one\n dimension in the returned tensors. The returned tensors will thus have\n ``total_num_tokens`` rows.\n\n Parameters\n ----------\n tokens : list of lists\n List of sentences, where each sentence is a list of tokens. Usually\n returned from ``data.loader.load_data``\n activations : list of numpy.ndarray\n List of *sentence representations*, where each *sentence representation*\n is a numpy matrix of shape\n ``[num tokens in sentence x concatenated representation size]``. Usually\n retured from ``data.loader.load_activations``\n task_specific_tag : str\n Label to assign tokens with unseen labels. This is particularly useful\n if some labels are never seen during train, but are present in the dev\n or test set. This is usually set to the majority class in the task.\n mappings : list of dicts\n List of four python dicts: ``label2idx``, ``idx2label``, ``src2idx`` and\n ``idx2src`` for classification tasks. List of two dicts ``src2idx`` and\n ``idx2src`` for regression tasks. Each dict represents either the\n mapping from class labels to indices and source tokens to indices or\n vice versa. Usually returned from a previous call to ``create_tensors``.\n task_type : str\n Either \"classification\" or \"regression\", indicate the kind of task that\n is being probed.\n binarized_tag : str, optional\n Tag/Label to create binary data. All other labels in the dataset are changed\n to OTHER. Defaults to None in which case the data labels are processed as-is.\n balance_data : bool, optional\n Whether the incoming data should be balanced. Data is balanced using \n utils.balance_binary_class_data for binary data and utils.balance_multi_class_data\n for multi-class data using undersampling. Defaults to False.\n dtype : str, optional\n None if the dtype of the activation tensor should be the same dtype as in the activations input\n e.g. 'float16' or 'float32' to enforce half-precision or full-precision floats\n\n\n Returns\n -------\n X : numpy.ndarray\n Numpy Matrix of size [``NUM_TOKENS`` x ``NUM_NEURONS``]\n y : numpy.ndarray\n Numpy vector of size [``NUM_TOKENS``]\n mappings : list of dicts\n List of four python dicts: ``label2idx``, ``idx2label``, ``src2idx`` and\n ``idx2src`` for classification tasks. List of two dicts ``src2idx`` and\n ``idx2src`` for regression tasks. Each dict represents either the\n mapping from class labels to indices and source tokens to indices or\n vice versa.\n\n Notes\n -----\n - ``mappings`` should be created exactly once, and should be reused for subsequent calls\n - For example, ``mappings`` can be created on train data, and the passed during the call for dev and test data.\n\n \"\"\"\n assert (\n task_type == \"classification\" or task_type == \"regression\"\n ), \"Invalid model type\"\n num_tokens = count_target_words(tokens)\n print(\"Number of tokens: \", num_tokens)\n\n num_neurons = activations[0].shape[1]\n\n source_tokens = tokens[\"source\"]\n target_tokens = tokens[\"target\"]\n\n ####### creating pos and source to index and reverse\n if mappings is not None:\n if task_type == \"classification\":\n label2idx, idx2label, src2idx, idx2src = mappings\n else:\n src2idx, idx2src = mappings\n else:\n if task_type == \"classification\":\n if binarized_tag: \n label2idx = {binarized_tag: 1, \"OTHER\": 0}\n idx2label = {1: binarized_tag, 0: \"OTHER\"}\n else:\n label2idx = tok2idx(target_tokens)\n idx2label = idx2tok(label2idx)\n\n src2idx = tok2idx(source_tokens)\n idx2src = idx2tok(src2idx)\n\n print(\"length of source dictionary: \", len(src2idx))\n if task_type == \"classification\":\n print(\"length of target dictionary: \", len(label2idx))\n\n if dtype==None:\n dtype=activations[0].dtype\n X = np.zeros((num_tokens, num_neurons), dtype=dtype)\n if task_type==\"classification\":\n y = np.zeros((num_tokens,), dtype=np.int)\n else:\n y = np.zeros((num_tokens,), dtype=np.float32)\n\n example_set = set()\n\n idx = 0\n for instance_idx, instance in enumerate(target_tokens):\n for token_idx, _ in enumerate(instance):\n if idx < num_tokens:\n X[idx] = activations[instance_idx][token_idx, :]\n\n example_set.add(source_tokens[instance_idx][token_idx])\n if task_type == \"classification\":\n current_target_token = target_tokens[instance_idx][token_idx]\n if binarized_tag and current_target_token != binarized_tag:\n current_target_token = \"OTHER\"\n if (\n mappings is not None\n and current_target_token not in label2idx\n ):\n y[idx] = label2idx[task_specific_tag]\n else:\n y[idx] = label2idx[current_target_token]\n elif task_type == \"regression\":\n y[idx] = float(target_tokens[instance_idx][token_idx])\n\n idx += 1\n\n print(idx)\n print(\"Total instances: %d\" % (num_tokens))\n print(list(example_set)[:20])\n\n print (\"Number of samples: \", X.shape[0])\n\n if balance_data:\n print (\"Balancing data ... \")\n if binarized_tag:\n X, y = balance_binary_class_data(X, y)\n else:\n X, y = balance_multi_class_data(X, y)\n print (\"Number of samples after balancing: \", X.shape[0])\n\n labels, freqs = np.unique(y, return_counts=True)\n\n print (\"Stats: Labels with their frequencies in the final set\")\n for idx, label in enumerate(labels):\n print (idx2label[label], freqs[idx])\n\n if task_type == \"classification\":\n return X, y, (label2idx, idx2label, src2idx, idx2src)\n return X, y, (src2idx, idx2src)\n\n\n################################## Statictics ##################################\ndef print_overall_stats(all_results):\n \"\"\"\n Method to pretty print overall results.\n\n .. warning::\n This method was primarily written to process results from internal\n scripts and pipelines.\n\n Parameters\n ----------\n all_results : dict\n Dictionary containing the probe, overall scores, scores from selected\n neurons, neuron ordering and neuron selections at various percentages\n\n \"\"\"\n probe = all_results[\"probe\"]\n weights = list(probe.parameters())[0].data.cpu()\n num_neurons = weights.numpy().shape[1]\n print(\n \"Overall accuracy: %0.02f%%\"\n % (100 * all_results[\"original_accs\"][\"__OVERALL__\"])\n )\n\n print(\"\")\n print(\"Global results\")\n print(\"10% Neurons\")\n print(\n \"\\tKeep Top accuracy: %0.02f%%\"\n % (100 * all_results[\"global_results\"][\"10%\"][\"keep_top_accs\"][\"__OVERALL__\"])\n )\n print(\n \"\\tKeep Random accuracy: %0.02f%%\"\n % (\n 100\n * all_results[\"global_results\"][\"10%\"][\"keep_random_accs\"][\"__OVERALL__\"]\n )\n )\n print(\n \"\\tKeep Bottom accuracy: %0.02f%%\"\n % (\n 100\n * all_results[\"global_results\"][\"10%\"][\"keep_bottom_accs\"][\"__OVERALL__\"]\n )\n )\n print(\"15% Neurons\")\n print(\n \"\\tKeep Top accuracy: %0.02f%%\"\n % (100 * all_results[\"global_results\"][\"15%\"][\"keep_top_accs\"][\"__OVERALL__\"])\n )\n print(\n \"\\tKeep Random accuracy: %0.02f%%\"\n % (\n 100\n * all_results[\"global_results\"][\"15%\"][\"keep_random_accs\"][\"__OVERALL__\"]\n )\n )\n print(\n \"\\tKeep Bottom accuracy: %0.02f%%\"\n % (\n 100\n * all_results[\"global_results\"][\"15%\"][\"keep_bottom_accs\"][\"__OVERALL__\"]\n )\n )\n print(\"20% Neurons\")\n print(\n \"\\tKeep Top accuracy: %0.02f%%\"\n % (100 * all_results[\"global_results\"][\"20%\"][\"keep_top_accs\"][\"__OVERALL__\"])\n )\n print(\n \"\\tKeep Random accuracy: %0.02f%%\"\n % (\n 100\n * all_results[\"global_results\"][\"20%\"][\"keep_random_accs\"][\"__OVERALL__\"]\n )\n )\n print(\n \"\\tKeep Bottom accuracy: %0.02f%%\"\n % (\n 100\n * all_results[\"global_results\"][\"20%\"][\"keep_bottom_accs\"][\"__OVERALL__\"]\n )\n )\n print(\"\")\n print(\"Full order of neurons:\")\n print(all_results[\"global_results\"][\"ordering\"])\n\n print(\"--------------------\")\n print(\"\")\n print(\"Local results\")\n for idx, percentage in enumerate(all_results[\"local_results\"][\"percentages\"]):\n print(\"Weight Mass percentage: %d%%\" % (percentage * 100))\n _, top_neurons, top_neurons_per_tag = all_results[\"local_results\"][\n \"local_top_neurons\"\n ][idx]\n print(\n \"Percentage of all neurons: %0.0f%%\"\n % (100 * len(top_neurons) / num_neurons)\n )\n print(\"Top Neurons:\", sorted(top_neurons))\n print(\"\")\n print(\"Top neurons per tag:\")\n for tag in top_neurons_per_tag:\n print(\"\\t\" + tag + \":\", sorted(top_neurons_per_tag[tag]))\n print(\"\")\n\n\ndef print_machine_stats(all_results):\n \"\"\"\n Method to print overall results in tsv format.\n\n .. warning::\n This method was primarily written to process results from internal\n scripts and pipelines.\n\n Parameters\n ----------\n all_results : dict\n Dictionary containing the probe, overall scores, scores from selected\n neurons, neuron ordering and neuron selections at various percentages\n\n \"\"\"\n\n probe = all_results[\"probe\"]\n weights = list(probe.parameters())[0].data.cpu()\n num_neurons = weights.numpy().shape[1]\n print(\"Filtering out:\")\n print(\n \"%0.2f\\t%0.2f\\t%0.2f\\t%0.2f\\t%0.2f\\t%0.2f\\t%0.2f\\t%0.2f\\t%0.2f\\t%0.2f\\t%s\"\n % (\n 100 * all_results[\"original_accs\"][\"__OVERALL__\"],\n 100 * all_results[\"global_results\"][\"10%\"][\"keep_top_accs\"][\"__OVERALL__\"],\n 100\n * all_results[\"global_results\"][\"10%\"][\"keep_random_accs\"][\"__OVERALL__\"],\n 100\n * all_results[\"global_results\"][\"10%\"][\"keep_bottom_accs\"][\"__OVERALL__\"],\n 100 * all_results[\"global_results\"][\"15%\"][\"keep_top_accs\"][\"__OVERALL__\"],\n 100\n * all_results[\"global_results\"][\"15%\"][\"keep_random_accs\"][\"__OVERALL__\"],\n 100\n * all_results[\"global_results\"][\"15%\"][\"keep_bottom_accs\"][\"__OVERALL__\"],\n 100 * all_results[\"global_results\"][\"20%\"][\"keep_top_accs\"][\"__OVERALL__\"],\n 100\n * all_results[\"global_results\"][\"20%\"][\"keep_random_accs\"][\"__OVERALL__\"],\n 100\n * all_results[\"global_results\"][\"20%\"][\"keep_bottom_accs\"][\"__OVERALL__\"],\n str(all_results[\"global_results\"][\"ordering\"][:300]),\n )\n )\n print(\"\\nZero out:\")\n print(\n \"%0.2f\\t%0.2f\\t%0.2f\\t%0.2f\\t%0.2f\\t%0.2f\\t%0.2f\\t%0.2f\\t%0.2f\\t%0.2f\"\n % (\n 100 * all_results[\"original_accs\"][\"__OVERALL__\"],\n 100\n * all_results[\"global_results\"][\"10%\"][\"zero_out_top_accs\"][\"__OVERALL__\"],\n 100\n * all_results[\"global_results\"][\"10%\"][\"zero_out_random_accs\"][\n \"__OVERALL__\"\n ],\n 100\n * all_results[\"global_results\"][\"10%\"][\"zero_out_bottom_accs\"][\n \"__OVERALL__\"\n ],\n 100\n * all_results[\"global_results\"][\"15%\"][\"zero_out_top_accs\"][\"__OVERALL__\"],\n 100\n * all_results[\"global_results\"][\"15%\"][\"zero_out_random_accs\"][\n \"__OVERALL__\"\n ],\n 100\n * all_results[\"global_results\"][\"15%\"][\"zero_out_bottom_accs\"][\n \"__OVERALL__\"\n ],\n 100\n * all_results[\"global_results\"][\"20%\"][\"zero_out_top_accs\"][\"__OVERALL__\"],\n 100\n * all_results[\"global_results\"][\"20%\"][\"zero_out_random_accs\"][\n \"__OVERALL__\"\n ],\n 100\n * all_results[\"global_results\"][\"20%\"][\"zero_out_bottom_accs\"][\n \"__OVERALL__\"\n ],\n )\n )\n\n for idx, percentage in enumerate(all_results[\"local_results\"][\"percentages\"]):\n print(\"\\nLocal %d%%:\" % (percentage * 100))\n top_neurons = all_results[\"local_results\"][\"local_top_neurons\"][idx][1]\n top_neurons_per_tag = all_results[\"local_results\"][\"local_top_neurons\"][idx][2]\n top_neurons_per_tag_list = {k: list(v) for k, v in top_neurons_per_tag.items()}\n print(\n \"%0.2f%%\\t%s\\t%s\"\n % (\n 100 * len(top_neurons) / num_neurons,\n str(sorted(top_neurons)),\n str(top_neurons_per_tag_list),\n )\n )\n\n\n################################ Data Balancing ################################\ndef balance_binary_class_data(X, y):\n \"\"\"\n Method to balance binary class data.\n\n .. note::\n The majority class is under-sampled randomly to match the minority class\n in it's size.\n\n Parameters\n ----------\n X : numpy.ndarray\n Numpy Matrix of size [``NUM_TOKENS`` x ``NUM_NEURONS``]. Usually\n returned from ``interpretation.utils.create_tensors``\n y : numpy.ndarray\n Numpy vector of size [``NUM_TOKENS``]. Usually returned from\n ``interpretation.utils.create_tensors``\n\n Returns\n -------\n X_balanced : numpy.ndarray\n Numpy matrix of size [``NUM_BALANCED_TOKENS`` x ``NUM_NEURONS``]\n y_balanced : numpy.ndarray\n Numpy vector of size [``NUM_BALANCED_TOKENS``]\n\n \"\"\"\n rus = RandomUnderSampler()\n X_res, y_res = rus.fit_resample(X, y)\n\n return X_res, y_res\n\n\ndef balance_multi_class_data(X, y, num_required_instances=None):\n \"\"\"\n Method to balance multi class data.\n\n .. note::\n All classes are under-sampled randomly to match the minority class in\n their size. If ``num_required_instances`` is provided, all classes are\n sampled proportionally so that the total number of selected examples is\n approximately ``num_required_instances`` (because of rounding proportions).\n\n Parameters\n ----------\n X : numpy.ndarray\n Numpy Matrix of size [``NUM_TOKENS`` x ``NUM_NEURONS``]. Usually\n returned from ``interpretation.utils.create_tensors``\n y : numpy.ndarray\n Numpy vector of size [``NUM_TOKENS``]. Usually returned from\n ``interpretation.utils.create_tensors``\n num_required_instances : int, optional\n Total number of required instances. All classes are sampled\n proportionally.\n\n Returns\n -------\n X_balanced : numpy.ndarray\n Numpy matrix of size [``NUM_BALANCED_TOKENS`` x ``NUM_NEURONS``]\n y_balanced : numpy.ndarray\n Numpy vector of size [``NUM_BALANCED_TOKENS``]\n\n \"\"\"\n if num_required_instances:\n total = y.shape[0]\n unique, counts = np.unique(y, return_counts=True)\n class_counts = dict(zip(unique, counts))\n num_instances_per_class = {\n key: math.ceil(count / total * num_required_instances)\n for key, count in class_counts.items()\n }\n print(num_instances_per_class)\n rus = RandomUnderSampler(sampling_strategy=num_instances_per_class)\n else:\n rus = RandomUnderSampler()\n\n X_res, y_res = rus.fit_resample(X, y)\n\n return X_res, y_res\n\ndef load_probe(probe_path):\n \"\"\"\n Loads a probe and its associated mappings from probe_path\n\n .. warning::\n This method is currently not implemented.\n\n Parameters\n ----------\n probe_path : str\n Path to a pkl object saved by interpretation.utils.save_probe\n\n Returns\n -------\n probe : interpretation.linear_probe.LinearProbe\n Trained probe model\n mappings : list of dicts\n List of four python dicts: ``label2idx``, ``idx2label``, ``src2idx`` and\n ``idx2src`` for classification tasks. List of two dicts ``src2idx`` and\n ``idx2src`` for regression tasks. Each dict represents either the\n mapping from class labels to indices and source tokens to indices or\n vice versa.\n\n \"\"\"\n pass\n\ndef save_probe(probe_path, probe, mappings):\n \"\"\"\n Saves a model and its associated mappings as a pkl object at probe_path\n\n .. warning::\n This method is currently not implemented.\n\n Parameters\n ----------\n probe_path : str\n Path to save a pkl object\n probe : interpretation.linear_probe.LinearProbe\n Trained probe model\n mappings : list of dicts\n List of four python dicts: ``label2idx``, ``idx2label``, ``src2idx`` and\n ``idx2src`` for classification tasks. List of two dicts ``src2idx`` and\n ``idx2src`` for regression tasks. Each dict represents either the\n mapping from class labels to indices and source tokens to indices or\n vice versa.\n\n \"\"\"\n pass" ]

[ [ "numpy.zeros", "numpy.unique" ] ]

DennisSoemers/rliable

[ "9f4c97d59196b70518f1ee3ba6d4f03a302c3241" ]

[ "rliable/library.py" ]

[ "# coding=utf-8\n# Copyright 2021 The Rliable Authors.\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"Main library functions for interval estimates and performance profiles.\"\"\"\n\nfrom typing import Callable, Dict, List, Optional, Tuple, Union, Mapping\nfrom absl import logging\nimport arch.bootstrap as arch_bs\nimport numpy as np\nfrom numpy import random\n\nFloat = Union[float, np.float32, np.float64]\n\n\n####################### Stratified Bootstrap #######################\nclass StratifiedBootstrap(arch_bs.IIDBootstrap):\n \"\"\"Bootstrap using stratified resampling.\n\n Supports numpy arrays. Data returned has the same type as the input data.\n Data entered using keyword arguments is directly accessibly as an attribute.\n\n To ensure a reproducible bootstrap, you must set the `random_state`\n attribute after the bootstrap has been created. See the example below.\n Note that `random_state` is a reserved keyword and any variable\n passed using this keyword must be an instance of `RandomState`.\n\n Examples\n --------\n Data can be accessed in a number of ways. Positional data is retained in\n the same order as it was entered when the bootstrap was initialized.\n Keyword data is available both as an attribute or using a dictionary syntax\n on kw_data.\n\n >>> from rliable.library import StratifiedBootstrap\n >>> from numpy.random import standard_normal\n >>> x = standard_normal((5, 50))\n >>> bs = StratifiedBootstrap(x)\n >>> for data in bs.bootstrap(100):\n ... bs_x = data[0][0]\n >>> bs.conf_int(np.mean, method='percentile', reps=50000) # 95% CIs for mean\n\n Set the random_state if reproducibility is required.\n\n >>> from numpy.random import RandomState\n >>> rs = RandomState(1234)\n >>> bs = StratifiedBootstrap(x, random_state=rs)\n\n See also: `arch.bootstrap.IIDBootstrap`\n\n Attributes:\n data: tuple, Two-element tuple with the pos_data in the first position and\n kw_data in the second (pos_data, kw_data). Derived from `IIDBootstrap`.\n pos_data: tuple, Tuple containing the positional arguments (in the order\n entered). Derived from `IIDBootstrap`.\n kw_data: dict, Dictionary containing the keyword arguments. Derived from\n `IIDBootstrap`.\n \"\"\"\n\n _name = 'Stratified Bootstrap'\n\n def __init__(\n self,\n *args: np.ndarray,\n random_state: Optional[random.RandomState] = None,\n task_bootstrap: bool = False,\n **kwargs: np.ndarray,\n ) -> None:\n \"\"\"Initializes StratifiedBootstrap.\n\n Args:\n *args: Positional arguments to bootstrap. Typically used for the\n performance on a suite of tasks with multiple runs/episodes. The inputs\n are assumed to be of the shape `(num_runs, num_tasks, ..)`.\n random_state: If specified, ensures reproducibility in uncertainty\n estimates.\n task_bootstrap: Whether to perform bootstrapping (a) over runs or (b) over\n both runs and tasks. Defaults to False which corresponds to (a). (a)\n captures the statistical uncertainty in the aggregate performance if the\n experiment is repeated using a different set of runs (e.g., changing\n seeds) on the same set of tasks. (b) captures the sensitivity of the\n aggregate performance to a given task and provides the performance\n estimate if we had used a larger unknown population of tasks.\n **kwargs: Keyword arguments, passed directly to `IIDBootstrap`.\n \"\"\"\n\n super().__init__(*args, random_state=random_state, **kwargs)\n self._args_shape = args[0].shape\n self._num_tasks = self._args_shape[1]\n self._parameters = [self._num_tasks, task_bootstrap]\n self._task_bootstrap = task_bootstrap\n self._strata_indices = self._get_strata_indices()\n\n def _get_strata_indices(self) -> List[np.ndarray]:\n \"\"\"Samples partial indices for bootstrap resamples.\n\n Returns:\n A list of arrays of size N x 1 x 1 x .., 1 x M x 1 x ..,\n 1 x 1 x L x .. and so on, where the `args_shape` is `N x M x L x ..`.\n \"\"\"\n ogrid_indices = tuple(slice(x) for x in (0, *self._args_shape[1:]))\n strata_indices = np.ogrid[ogrid_indices]\n return strata_indices[1:]\n\n def update_indices(self,) -> Tuple[np.ndarray, ...]:\n \"\"\"Selects the indices to sample from the bootstrap distribution.\"\"\"\n # `self._num_items` corresponds to the number of runs\n indices = np.random.choice(self._num_items, self._args_shape, replace=True)\n if self._task_bootstrap:\n task_indices = np.random.choice(\n self._num_tasks, self._strata_indices[0].shape, replace=True)\n return (indices, task_indices, *self._strata_indices[1:])\n return (indices, *self._strata_indices)\n\n\nclass StratifiedIndependentBootstrap(arch_bs.IndependentSamplesBootstrap):\n \"\"\"Stratified Bootstrap where each input is independently resampled.\n\n This bootstrap is useful for computing CIs for metrics which take multiple\n score arrays, possibly with different number of runs, as input, such as\n average probability of improvement. See also: `StratifiedBootstrap` and\n `arch_bs.IndependentSamplesBootstrap`.\n\n Attributes:\n data: tuple, Two-element tuple with the pos_data in the first position and\n kw_data in the second (pos_data, kw_data). Derived from\n `IndependentSamplesBootstrap`.\n pos_data: tuple, Tuple containing the positional arguments (in the order\n entered). Derived from `IndependentSamplesBootstrap`.\n kw_data: dict, Dictionary containing the keyword arguments. Derived from\n `IndependentSamplesBootstrap`.\n \"\"\"\n\n def __init__(\n self,\n *args: np.ndarray,\n random_state: Optional[random.RandomState] = None,\n **kwargs: np.ndarray,\n ) -> None:\n \"\"\"Initializes StratifiedIndependentSamplesBootstrap.\n\n Args:\n *args: Positional arguments to bootstrap. Typically used for the\n performance on a suite of tasks with multiple runs/episodes. The inputs\n are assumed to be of the shape `(num_runs, num_tasks, ..)`.\n random_state: If specified, ensures reproducibility in uncertainty\n estimates.\n **kwargs: Keyword arguments, passed directly to `IIDBootstrap`.\n \"\"\"\n\n super().__init__(*args, random_state=random_state, **kwargs)\n self._args_shapes = [arg.shape for arg in args]\n self._kwargs_shapes = {key: val.shape for key, val in self._kwargs.items()}\n self._args_strata_indices = [\n self._get_strata_indices(arg_shape) for arg_shape in self._args_shapes\n ]\n self._kwargs_strata_indices = {\n key: self._get_strata_indices(kwarg_shape)\n for key, kwarg_shape in self._kwargs_shapes.items()\n }\n\n def _get_strata_indices(\n self, array_shape: Tuple[int, ...]) -> List[np.ndarray]:\n \"\"\"Samples partial indices for bootstrap resamples.\n\n Args:\n array_shape: Shape of array for which strata indices are created.\n\n Returns:\n A list of arrays of size N x 1 x 1 x .., 1 x M x 1 x ..,\n 1 x 1 x L x .. and so on, where the `array_shape` is `N x M x L x ..`.\n \"\"\"\n ogrid_indices = tuple(slice(x) for x in (0, *array_shape[1:]))\n strata_indices = np.ogrid[ogrid_indices]\n return strata_indices[1:]\n\n def _get_indices(self, num_runs: int, array_shape: Tuple[int, ...],\n strata_indices: List[np.ndarray]) -> Tuple[np.ndarray, ...]:\n \"\"\"Helper function for updating bootstrap indices.\"\"\"\n indices = np.random.choice(num_runs, array_shape, replace=True)\n return (indices, *strata_indices)\n\n def update_indices(\n self,\n ) -> Tuple[List[Tuple[np.ndarray, ...]], Dict[str, Tuple[np.ndarray, ...]]]:\n \"\"\"Update independent sampling indices for the next bootstrap iteration.\"\"\"\n\n pos_indices = [\n self._get_indices(self._num_arg_items[i], self._args_shapes[i],\n self._args_strata_indices[i])\n for i in range(self._num_args)\n ]\n kw_indices = {}\n for key in self._kwargs:\n kw_indices[key] = self._get_indices(self._num_kw_items[key],\n self._kwargs_shapes[key],\n self._kwargs_strata_indices[key])\n return pos_indices, kw_indices\n\n\n####################### Interval Estimates #######################\ndef get_interval_estimates(\n score_dict: Union[Mapping[str, np.ndarray], Mapping[str, List[np.ndarray]]],\n func: Callable[..., np.ndarray],\n method: str = 'percentile',\n task_bootstrap: bool = False,\n reps: int = 50000,\n confidence_interval_size: Float = 0.95,\n random_state: Optional[random.RandomState] = None,\n) -> Tuple[Dict[str, np.ndarray], Dict[str, np.ndarray]]:\n \"\"\"Computes interval estimates via stratified bootstrap confidence intervals.\n\n Args:\n score_dict: A dictionary of scores for each method where scores are arranged\n as a matrix of the shape (`num_runs` x `num_tasks` x ..). For example, the\n scores could be 2D matrix containing final scores of the algorithm or a 3D\n matrix containing evaluation scores at multiple points during training.\n func: Function that computes the aggregate performance, which outputs a 1D\n numpy array. See Notes for requirements. For example, if computing\n estimates for interquartile mean across all runs, pass the function as\n `lambda x: np.array([metrics.aggregate_IQM])`.\n method: One of `basic`, `percentile`, `bc` (identical to `debiased`,\n `bias-corrected’), or ‘bca`.\n task_bootstrap: Whether to perform bootstrapping over tasks in addition to\n runs. Defaults to False. See `StratifiedBoostrap` for more details.\n reps: Number of bootstrap replications.\n confidence_interval_size: Coverage of confidence interval. Defaults to 95%.\n random_state: If specified, ensures reproducibility in uncertainty\n estimates.\n\n Returns:\n point_estimates: A dictionary of point estimates obtained by applying `func`\n on score data corresponding to each key in `data_dict`.\n interval_estimates: Confidence intervals~(CIs) for point estimates. Default\n is to return 95% CIs. Returns a np array of size (2 x ..) where the first\n row contains the lower bounds while the second row contains the upper\n bound of the 95% CIs.\n Notes:\n When there are no extra keyword arguments, the function is called\n\n .. code:: python\n\n func(*args, **kwargs)\n\n where args and kwargs are the bootstrap version of the data provided\n when setting up the bootstrap. When extra keyword arguments are used,\n these are appended to kwargs before calling func.\n\n The bootstraps are:\n\n * 'basic' - Basic confidence using the estimated parameter and\n difference between the estimated parameter and the bootstrap\n parameters.\n * 'percentile' - Direct use of bootstrap percentiles.\n * 'bc' - Bias corrected using estimate bootstrap bias correction.\n * 'bca' - Bias corrected and accelerated, adding acceleration parameter\n to 'bc' method.\n \"\"\"\n interval_estimates, point_estimates = {}, {}\n for key, scores in score_dict.items():\n logging.info('Calculating estimates for %s ...', key)\n if isinstance(scores, np.ndarray):\n stratified_bs = StratifiedBootstrap(\n scores, task_bootstrap=task_bootstrap, random_state=random_state)\n point_estimates[key] = func(scores)\n else:\n # Pass arrays as separate arguments, `task_bootstrap` is not supported\n stratified_bs = StratifiedIndependentBootstrap(\n *scores,\n random_state=random_state)\n point_estimates[key] = func(*scores)\n interval_estimates[key] = stratified_bs.conf_int(\n func, reps=reps, size=confidence_interval_size, method=method)\n return point_estimates, interval_estimates\n\n\n####################### Performance Profiles #######################\ndef run_score_deviation(scores: np.ndarray, tau: Float) -> Float:\n \"\"\"Evaluates how many `scores` are above `tau` averaged across all runs.\"\"\"\n return np.mean(scores > tau)\n\n\ndef mean_score_deviation(scores: np.ndarray, tau: Float) -> Float:\n \"\"\"Evaluates how many average task `scores` are above `tau`.\"\"\"\n return np.mean(np.mean(scores, axis=0) > tau)\n\n\nscore_distributions = np.vectorize(run_score_deviation, excluded=[0])\naverage_score_distributions = np.vectorize(mean_score_deviation, excluded=[0])\n\n\ndef create_performance_profile(\n score_dict: Mapping[str, np.ndarray],\n tau_list: Union[List[Float], np.ndarray],\n use_score_distribution: bool = True,\n custom_profile_func: Optional[Callable[..., np.ndarray]] = None,\n method: str = 'percentile',\n task_bootstrap: bool = False,\n reps: int = 2000,\n confidence_interval_size: Float = 0.95\n) -> Tuple[Dict[str, np.ndarray], Dict[str, np.ndarray]]:\n \"\"\"Function for calculating performance profiles.\n\n Args:\n score_dict: A dictionary of scores for each method where scores are arranged\n as a matrix of the shape (`num_runs` x `num_tasks` x ..).\n tau_list: List or 1D numpy array of threshold values on which the profile is\n evaluated.\n use_score_distribution: Whether to report score distributions or average\n score distributions. Defaults to score distributions for smaller\n uncertainty in reported results with unbiased profiles.\n custom_profile_func: Custom performance profile function. Can be used to\n compute performance profiles other than score distributions.\n method: Bootstrap method for `StratifiedBootstrap`, defaults to percentile.\n task_bootstrap: Whether to perform bootstrapping over tasks in addition to\n runs. Defaults to False. See `StratifiedBoostrap` for more details.\n reps: Number of bootstrap replications.\n confidence_interval_size: Coverage of confidence interval. Defaults to 95%.\n\n Returns:\n profiles: A dictionary of performance profiles for each key in `score_dict`.\n Each profile is a 1D np array of same size as `tau_list`.\n profile_cis: The 95% confidence intervals of profiles evaluated at\n all threshdolds in `tau_list`.\n \"\"\"\n\n if custom_profile_func is None:\n\n def profile_function(scores):\n if use_score_distribution:\n # Performance profile for scores across all tasks and runs\n return score_distributions(scores, tau_list)\n # Performance profile for task scores averaged across runs\n return average_score_distributions(scores, tau_list)\n else:\n profile_function = lambda scores: custom_profile_func(scores, tau_list)\n\n profiles, profile_cis = get_interval_estimates(\n score_dict,\n func=profile_function,\n task_bootstrap=task_bootstrap,\n method=method,\n reps=reps,\n confidence_interval_size=confidence_interval_size)\n return profiles, profile_cis\n" ]

[ [ "numpy.vectorize", "numpy.mean", "numpy.random.choice" ] ]

NREL/WaterTAP3

[ "74b83dbd189784ccfddac4bc5d27002190473619" ]

[ "watertap3/watertap3/wt_units/ion_exchange.py" ]

[ "import pandas as pd\nfrom pyomo.environ import *\nfrom pyomo.environ import units as pyunits\nfrom pyomo.repn.plugins.baron_writer import NonNegativeReals\n\nfrom watertap3.utils import financials\nfrom watertap3.wt_units.wt_unit import WT3UnitProcess\n\n## REFERENCE: ADD REFERENCE HERE\n\nmodule_name = 'ion_exchange'\nbasis_year = 2016 # 2016 is costing year for EPA component costing data\ntpec_or_tic = 'TIC'\n\n\nclass UnitProcess(WT3UnitProcess):\n\n def fixed_cap(self, unit_params):\n '''\n Docstrings go here.\n \n :return:\n '''\n time = self.flowsheet().config.time\n\n self.total_ix_cap = Var(time,\n initialize=25,\n domain=NonNegativeReals,\n doc='Total ion exchange FCI [$MM]')\n\n self.cap_per_column = Var(time,\n initialize=1,\n domain=NonNegativeReals,\n doc='Capital per column [$MM]')\n\n self.column_total_cap = Var(time,\n initialize=1,\n domain=NonNegativeReals,\n doc='Total column capital [$MM]')\n\n self.resin_unit_cap = Var(time,\n initialize=4000,\n domain=NonNegativeReals,\n doc='Resin cap per m3 [$/m3]')\n\n self.resin_cap = Var(time,\n initialize=1E4,\n domain=NonNegativeReals,\n doc='Resin capital [$MM]')\n\n self.regen_pump_cap = Var(time,\n initialize=100,\n domain=NonNegativeReals,\n doc='Pump capital for regen cycle [$MM]')\n\n self.bw_pump_cap = Var(time,\n initialize=100,\n domain=NonNegativeReals,\n doc='Pump capital for backwash cycle [$MM]')\n\n self.rinse_pump_cap = Var(time,\n initialize=100,\n domain=NonNegativeReals,\n doc='Pump capital for rinse cycle [$MM]')\n\n self.boost_pump_cap = Var(time,\n initialize=100,\n domain=NonNegativeReals,\n doc='Pump capital for booster pump [#MM]')\n\n if self.pv_material == 'carbon_w_stainless_internals':\n self.cap_per_column_constr = Constraint(expr=self.cap_per_column[self.t] ==\n (16504 * self.column_vol[self.t] ** 0.43) * 1E-6)\n if self.pv_material == 'carbon_w_plastic_internals':\n self.cap_per_column_constr = Constraint(expr=self.cap_per_column[self.t] ==\n (9120 * self.column_vol[self.t] ** 0.49) * 1E-6)\n if self.pv_material == 'fiberglass':\n self.cap_per_column_constr = Constraint(expr=self.cap_per_column[self.t] ==\n (5637 * self.column_vol[self.t] ** 0.9) * 1E-6)\n\n self.col_total_cap_constr = Constraint(expr=self.column_total_cap[self.t] == self.cap_per_column[self.t] * (self.num_columns[self.t] + 1))\n\n self.resin_unit_cap.fix(self.resin_dict[self.resin_type])\n\n self.resin_cap_constr = Constraint(expr=self.resin_cap[self.t] == ((self.resin_vol[self.t] + self.resin_per_column[self.t]) * self.resin_unit_cap[self.t]) * 1E-6) # include an additional resin vol per column to account for the extra column\n\n self.regen_pump_cap_constr = Constraint(expr=self.regen_pump_cap[self.t] == (-24.257 * self.regen_flow[self.t] ** 2 + 2803.7 * self.regen_flow[self.t] + 7495.7) *\n (self.num_columns[self.t] + 1) * 1E-6) # assumes centrifugal pump and 1 pump per column\n\n self.bw_pump_cap_constr = Constraint(expr=self.bw_pump_cap[self.t] == (-24.257 * self.bw_flow[self.t] ** 2 + 2803.7 * self.bw_flow[self.t] + 7495.7) *\n (self.num_columns[self.t] + 1) * 1E-6) # assumes centrifugal pump and 1 pump per column\n\n self.rinse_pump_cap_constr = Constraint(expr=self.rinse_pump_cap[self.t] == (-24.257 * self.rinse_flow[self.t] ** 2 + 2803.7 * self.rinse_flow[self.t] + 7495.7) *\n (self.num_columns[self.t] + 1) * 1E-6) # assumes centrifugal pump and 1 pump per column\n\n self.flow_per_col_m3_min = pyunits.convert(self.flow_per_column[self.t], to_units=pyunits.m ** 3 / pyunits.min)\n\n self.boost_pump_cap_constr = Constraint(expr=self.boost_pump_cap[self.t] == (-24.257 * self.flow_per_col_m3_min ** 2 + 2803.7 * self.flow_per_col_m3_min + 7495.7) *\n (self.num_columns[self.t] + 1) * 1E-6) # assumes centrifugal pump and 1 pump per column\n\n self.total_ix_cap_constr = Constraint(expr=self.total_ix_cap[self.t] ==\n self.column_total_cap[self.t] + self.resin_cap[self.t] + self.regen_pump_cap[self.t] + self.bw_pump_cap[self.t] + self.rinse_pump_cap[self.t] + self.boost_pump_cap[self.t])\n return self.total_ix_cap[self.t] * self.tpec_tic\n\n def elect(self):\n\n '''\n Electricity intensity for ion exchange\n\n :return:\n '''\n time = self.flowsheet().config.time\n\n self.main_pump_ei = Var(time,\n initialize=4E-6,\n domain=NonNegativeReals,\n doc='Electricity intensity for main pump [kWh/m3]')\n\n self.regen_pump_ei = Var(time,\n initialize=4E-6,\n domain=NonNegativeReals,\n doc='Electricity intensity for regen pump [kWh/m3]')\n\n self.bw_pump_ei = Var(time,\n initialize=4E-6,\n domain=NonNegativeReals,\n doc='Electricity intensity for backwash pump [kWh/m3]')\n\n self.rinse_pump_ei = Var(time,\n initialize=4E-6,\n domain=NonNegativeReals,\n doc='Electricity intensity for rinse pump [kWh/m3]')\n\n self.total_pump_ei = Var(time,\n initialize=4E-5,\n domain=NonNegativeReals,\n doc='Total pumping electricity intensity [kWh/m3]')\n\n flow_out_m3_hr = pyunits.convert(self.flow_vol_out[self.t], to_units=pyunits.m ** 3 / pyunits.hr)\n flow_waste_m3_hr = pyunits.convert(self.flow_vol_waste[self.t], to_units=pyunits.m ** 3 / pyunits.hr)\n\n self.main_pump_ei_constr = Constraint(expr=self.main_pump_ei[self.t] == ((1000 * 9.81 * self.pressure_drop[self.t] * 0.703249) / (3.6E6 * 0.7)) / flow_out_m3_hr)\n\n self.regen_pump_ei_constr = Constraint(expr=self.regen_pump_ei[self.t] == ((1000 * 9.81) / (3.6E6 * 0.7)) / flow_waste_m3_hr)\n\n self.bw_pump_ei_constr = Constraint(expr=self.bw_pump_ei[self.t] == ((1000 * 9.81) / (3.6E6 * 0.7)) / flow_waste_m3_hr)\n\n self.rinse_pump_ei_constr = Constraint(expr=self.rinse_pump_ei[self.t] == ((1000 * 9.81) / (3.6E6 * 0.7)) / flow_waste_m3_hr)\n\n self.total_pump_ei_constr = Constraint(expr=self.total_pump_ei[self.t] == self.main_pump_ei[self.t] + self.regen_pump_ei[self.t] + self.bw_pump_ei[self.t] + self.rinse_pump_ei[self.t])\n\n return self.total_pump_ei[self.t] * self.tpec_tic\n\n def sba(self, unit_params):\n '''\n Function for Strong-Base Anion Exchange Model\n\n :param unit_params:\n :return:\n '''\n\n time = self.flowsheet().config.time\n\n ### REGEN VARIABLES\n\n self.regen_dose = Var(time,\n initialize=300,\n domain=NonNegativeReals,\n units=pyunits.kg / pyunits.m ** 3,\n bounds=(80, 500),\n doc='NaCl dose required for regeneration [kg/m3]')\n\n self.regen_rate = Var(time,\n initialize=4,\n domain=NonNegativeReals,\n bounds=(2, 5),\n doc='Regeneration rate [BV/hr]')\n\n self.regen_density = Var(time,\n initialize=1000,\n domain=NonNegativeReals,\n units=pyunits.kg / pyunits.m ** 3,\n bounds=(990, 1200),\n doc='Density of NaCl regen solution [kg/m3]')\n\n self.regen_ww = Var(time,\n initialize=0.1,\n domain=NonNegativeReals,\n bounds=(0.015, 0.26),\n doc='Strength of NaCl solution w/w [kg NaCl/kg soln]')\n\n self.regen_conc = Var(time,\n initialize=110,\n domain=NonNegativeReals,\n units=pyunits.kg / pyunits.m ** 3,\n doc='Concentration of regen solution [kg/m3]')\n\n self.regen_vol = Var(time,\n initialize=2,\n domain=NonNegativeReals,\n doc='m3 of regen solution per m3 resin')\n\n self.regen_soln_per_column = Var(time,\n initialize=50,\n domain=NonNegativeReals,\n units=pyunits.m ** 3,\n doc='Regen solution used per column [m3/column]')\n\n self.regen_soln_per_column_annual = Var(time,\n initialize=1E3,\n domain=NonNegativeReals,\n units=pyunits.m ** 3 / pyunits.year,\n doc='Annual regen used per column [m3/year]')\n\n self.regen_soln_annual = Var(time,\n initialize=1E5,\n domain=NonNegativeReals,\n units=pyunits.m ** 3 / pyunits.year,\n doc='Total volume regen solution used [m3/year]')\n\n self.regen_time_per_column = Var(time,\n initialize=5,\n domain=NonNegativeReals,\n units=pyunits.min,\n doc='Regen time per column [min]')\n\n self.regen_flow = Var(time,\n initialize=10,\n domain=NonNegativeReals,\n units=pyunits.m ** 3 / pyunits.min,\n doc='Regeneration flow rate [m3/min]')\n\n self.num_regen_per_column_annual = Var(time,\n initialize=200,\n domain=NonNegativeReals,\n doc='Number of regen cycles per year')\n\n self.salt_per_regen_per_column = Var(time,\n initialize=5E3,\n domain=NonNegativeReals,\n doc='Number of regen cycles per year')\n\n self.salt_per_column_annual = Var(time,\n initialize=1E5,\n domain=NonNegativeReals,\n units=pyunits.kg / pyunits.year,\n doc='Mass of salt per column per year [kg/yr]')\n\n self.salt_total_annual = Var(time,\n initialize=1E6,\n domain=NonNegativeReals,\n units=pyunits.kg / pyunits.year,\n doc='Mass of salt per year [kg/yr]')\n\n self.salt_dose = Var(time,\n initialize=0.1,\n domain=NonNegativeReals,\n units=pyunits.kg / pyunits.m ** 3,\n doc='Salt dose for system [kg/m3]')\n\n self.total_regen_time = Var(time,\n initialize=30,\n units=pyunits.min,\n domain=NonNegativeReals,\n doc='Total regeneration cycle time [min]')\n\n self.regen_dose.fix(300)\n\n try:\n self.regen_ww.fix(unit_params['regen_ww'])\n except KeyError:\n self.regen_ww.fix(0.1)\n\n ### BACKWASH VARIABLES\n\n self.bw_rate = Var(time,\n initialize=6,\n domain=NonNegativeReals,\n units=pyunits.m / pyunits.hour,\n bounds=(4.5, 8),\n doc='Backwash rate [m/hr]')\n\n self.bw_time = Var(time,\n initialize=6,\n domain=NonNegativeReals,\n units=pyunits.minute,\n bounds=(4, 20),\n doc='Backwash time [min]')\n\n self.bw_flow = Var(time,\n initialize=5,\n domain=NonNegativeReals,\n units=pyunits.m ** 3 / pyunits.minute,\n doc='Backwash flow rate [m3/min]')\n\n self.bed_expansion = Var(time,\n initialize=0.5,\n domain=NonNegativeReals,\n units=pyunits.dimensionless,\n bounds=(0.4, 0.8),\n doc='Resin bed expansion during backwash [%]')\n\n self.bed_expansion_h = Var(time,\n # initialize=0.5,\n domain=NonNegativeReals,\n units=pyunits.m,\n bounds=(0.5, 3),\n doc='Resin bed expansion during backwash [m]')\n\n # self.bw_time.fix(6)\n self.bw_time.fix(12)\n\n ### RINSE VARIABLES\n\n self.rinse_bv = Var(time,\n initialize=5,\n domain=NonNegativeReals,\n bounds=(2, 10),\n doc='Number of bed volumes for rinse step [BV]')\n\n self.rinse_vol_per_column = Var(time,\n initialize=150,\n domain=NonNegativeReals,\n units=pyunits.m ** 3,\n doc='Rinse volume per column [m3/col]')\n\n self.rinse_vol_per_column_annual = Var(time,\n initialize=5E3,\n domain=NonNegativeReals,\n units=pyunits.m ** 3 / pyunits.year,\n doc='Rinse volume per column [m3/yr]')\n\n self.rinse_time_per_column = Var(time,\n initialize=4,\n domain=NonNegativeReals,\n units=pyunits.min,\n doc='Rinse time per column [min]')\n\n self.rinse_flow = Var(time,\n initialize=2,\n domain=NonNegativeReals,\n units=pyunits.m ** 3 / pyunits.min,\n doc='Rinse step flow rate [m3/min]')\n\n self.rinse_bv.fix(5)\n\n ### RESIN AND FLOW VARIABLES\n\n ix_df = self.ix_df = pd.read_csv('data/ix_sba.csv', index_col='constituent')\n self.cons = [c for c in self.config.property_package.component_list if c in ix_df.index]\n ix_df = self.ix_df = ix_df.loc[self.cons].copy()\n self.sep_factor_dict = ix_df.to_dict()['sep_factor']\n self.meq_conv_dict = ix_df.to_dict()['meq']\n\n try:\n self.target = unit_params['target']\n except:\n self.cons_df = self.source_df.loc[[c for c in self.cons if c != 'chloride']].copy()\n self.cons_df['meq_L'] = [(self.cons_df.loc[c].value * 1E3) / self.meq_conv_dict[c] for c in self.cons if c != 'chloride']\n self.target = self.cons_df.meq_L.idxmax()\n\n for k, v in self.sep_factor_dict.items():\n if v > self.sep_factor_dict[self.target]:\n self.sep_factor_dict[k] = 0.99 * self.sep_factor_dict[self.target]\n\n self.sep_factor = Param(self.cons,\n initialize=self.sep_factor_dict)\n\n self.meq_conv = Param(self.cons,\n initialize=self.meq_conv_dict)\n\n self.target_removal = Var(time,\n initialize=1,\n domain=NonNegativeReals,\n bounds=(0.0001, 1),\n doc='Removal fraction for target compound')\n\n self.sfr = Var(time,\n initialize=30,\n domain=NonNegativeReals,\n bounds=(6, 50),\n doc='Service flow rate [BV/hr]')\n\n self.loading_rate = Var(time,\n initialize=20,\n domain=NonNegativeReals,\n bounds=(10, 40),\n units=pyunits.m / pyunits.hr,\n doc='Column loading rate (superficial velocity) [m/hr]')\n\n self.cycle_time = Var(time,\n initialize=100,\n domain=NonNegativeReals,\n units=pyunits.hr,\n doc='Service cycle time [hr]')\n\n self.ebct = Var(time,\n initialize=1.1,\n domain=NonNegativeReals,\n units=pyunits.min,\n doc='Empty Bed Contact Time [min]')\n\n self.mg_L = Var(time,\n self.cons,\n initialize=1,\n domain=NonNegativeReals,\n doc='Influent concentration in mg/L')\n\n self.meq_L = Var(time,\n self.cons,\n initialize=0.1,\n domain=NonNegativeReals,\n doc='Influent concentration in meq/L')\n\n self.mass_in = Var(time,\n self.cons,\n initialize=200,\n domain=NonNegativeReals,\n doc='Influent mass [eq]')\n\n self.mass_removed = Var(time,\n self.cons,\n initialize=10,\n domain=NonNegativeReals,\n doc='Mass removed [eq]')\n\n self.frac_removed = Var(time,\n self.cons,\n initialize=0.8,\n domain=NonNegativeReals,\n doc='Fraction removed [%]')\n\n self.denom_resin = Var(time,\n initialize=1,\n domain=NonNegativeReals)\n\n self.denom_aq = Var(time,\n initialize=1,\n domain=NonNegativeReals)\n\n self.resin_conc = Var(time,\n self.cons,\n initialize=0.1,\n domain=NonNegativeReals,\n doc='Resin phase concentration of each ion [eq/L resin]')\n\n self.max_vol_treated = Var(time,\n initialize=5E3,\n domain=NonNegativeReals,\n bounds=(100, 1E6),\n units=pyunits.L / pyunits.L,\n doc='Max volume of water treated before breakthrough [L water/L resin]')\n\n self.resin_capacity = Var(time,\n initialize=1.2,\n domain=NonNegativeReals,\n bounds=(0.9, 1.5),\n doc='Resin capacity [eq/L]')\n\n self.resin_vol = Var(time,\n # initialize=100,\n domain=NonNegativeReals,\n units=pyunits.m ** 3,\n doc='Resin volume needed [m3]')\n\n self.resin_area = Var(time,\n initialize=100,\n domain=NonNegativeReals,\n units=pyunits.m ** 2,\n doc='Resin cross-sectional area needed [m2]')\n\n self.resin_depth = Var(time,\n initialize=1.5,\n domain=NonNegativeReals,\n bounds=(0.75, 3),\n units=pyunits.m,\n doc='Resin bed depth [m]')\n\n self.resin_depth_to_column_diam_ratio = Var(time,\n initialize=1,\n domain=NonNegativeReals,\n bounds=(0.6, 1.6),\n units=pyunits.dimensionless,\n doc='Ratio of resin depth to column height')\n\n self.resin_per_column = Var(time,\n initialize=15,\n domain=NonNegativeReals,\n units=pyunits.m ** 3,\n doc='Resin per column [m3]')\n\n self.resin_loss_frac_annual = Var(time,\n initialize=0.045,\n domain=NonNegativeReals,\n bounds=(3.75, 5.25),\n doc='Fraction of resin replaced per year [%]')\n\n self.resin_loss_annual = Var(time,\n initialize=20,\n domain=NonNegativeReals,\n units=pyunits.m ** 3,\n doc='Resin replaced per year [m3]')\n\n #### COLUMN VARIABLES\n\n self.column_h = Var(time,\n initialize=2,\n domain=NonNegativeReals,\n units=pyunits.m,\n bounds=(1, 16),\n doc='Column height [m]')\n\n self.column_diam = Var(time,\n initialize=2,\n domain=NonNegativeReals,\n units=pyunits.m,\n bounds=(1, 4),\n doc='Column diameter [m]')\n\n self.column_area = Var(time,\n initialize=15,\n domain=NonNegativeReals,\n units=pyunits.m ** 2,\n doc='Column cross-sectional area [m2]')\n\n if self.pv_material == 'fiberglass':\n self.column_vol = Var(time,\n initialize=2,\n domain=NonNegativeReals,\n bounds=(0.5, 4),\n units=pyunits.m ** 3,\n doc='Column volume [m3]')\n\n else:\n self.column_vol = Var(time,\n initialize=35,\n domain=NonNegativeReals,\n bounds=(0.5, 25),\n units=pyunits.m ** 3,\n doc='Column volume [m3]')\n\n self.num_columns = Var(time,\n initialize=2,\n domain=NonNegativeReals,\n bounds=(1, 1E5),\n units=pyunits.dimensionless,\n doc='Number of columns in parallel')\n\n self.underdrain_h = Var(time,\n initialize=0.5,\n domain=NonNegativeReals,\n units=pyunits.m,\n doc='Underdrain height [m]')\n\n self.distributor_h = Var(time,\n initialize=1,\n domain=NonNegativeReals,\n units=pyunits.m,\n doc='Distributor height [m]')\n\n self.flow_per_column = Var(time,\n initialize=250,\n domain=NonNegativeReals,\n units=pyunits.m ** 3 / pyunits.hr,\n doc='Flow per column [m3/hr]')\n\n self.pressure_drop = Var(time,\n initialize=14,\n domain=NonNegativeReals,\n units=pyunits.psi,\n bounds=(0, 25),\n doc='Pressure drop across column [psi]')\n\n self.resin_capacity.fix(1.2)\n # self.resin_capacity.fix(0.9435)\n # self.sfr.fix(30)\n self.loading_rate.fix(20)\n self.underdrain_h.fix(0.5)\n self.distributor_h.fix(1)\n self.resin_loss_frac_annual.fix(0.045)\n # self.column_diam.fix(3)\n\n try:\n self.target_removal = unit_params['target_removal']\n except KeyError:\n self.target_removal.fix(1)\n\n flow_out_m3_hr = pyunits.convert(self.flow_vol_out[self.t], to_units=pyunits.m ** 3 / pyunits.hr)\n flow_out_m3_yr = pyunits.convert(self.flow_vol_out[self.t], to_units=pyunits.m ** 3 / pyunits.year)\n flow_out_L_hr = pyunits.convert(self.flow_vol_out[self.t], to_units=pyunits.L / pyunits.hr)\n\n ############################# CONSTRAINTS START\n #### RESIN AND PERFORMANCE CONSTRAINTS\n\n self.mg_L_constr = ConstraintList()\n self.meq_L_constr = ConstraintList()\n self.resin_conc_constr = ConstraintList()\n self.mass_in_constr = ConstraintList()\n self.mass_removed_constr = ConstraintList()\n self.frac_removed_constr = ConstraintList()\n\n for c in self.cons:\n self.mg_L_constr.add(self.mg_L[self.t, c] == (self.conc_mass_in[self.t, c] * 1E3))\n self.meq_L_constr.add(self.meq_L[self.t, c] == self.mg_L[self.t, c] / self.meq_conv[c])\n self.resin_conc_constr.add(self.resin_conc[self.t, c] == (self.resin_capacity[self.t] * self.sep_factor[c] * self.meq_L[self.t, c]) /\n self.denom_resin[self.t])\n self.mass_in_constr.add(self.mass_in[self.t, c] == self.meq_L[self.t, c] * flow_out_m3_hr * self.cycle_time[self.t] * 1E-3)\n self.mass_removed_constr.add(self.mass_removed[self.t, c] == (self.resin_conc[self.t, c] / self.max_vol_treated[self.t]) * flow_out_m3_hr * self.cycle_time[self.t])\n self.frac_removed_constr.add(self.frac_removed[self.t, c] == 0.99 * (self.mass_removed[self.t, c] / self.mass_in[self.t, c]))\n\n self.denom_resin_constr = Constraint(expr=self.denom_resin[self.t] == sum(self.meq_L[self.t, c] * self.sep_factor[c] for c in self.cons))\n self.denom_aq_constr = Constraint(expr=self.denom_aq[self.t] == sum(self.resin_conc[self.t, c] / self.sep_factor[c] for c in self.cons))\n\n self.max_vol_treated_constr = Constraint(expr=self.max_vol_treated[self.t] == (self.resin_conc[self.t, self.target] * 1E3) /\n (self.meq_L[self.t, self.target] * self.target_removal[self.t]))\n\n self.resin_vol_constr = Constraint(expr=self.resin_vol[self.t] == flow_out_m3_hr / self.sfr[self.t])\n resin_vol_L = pyunits.convert(self.resin_vol[self.t], to_units=pyunits.L)\n\n self.resin_depth_to_column_diam_ratio_constr = Constraint(expr=self.resin_depth_to_column_diam_ratio[self.t] == self.resin_depth[self.t] / self.column_diam[self.t])\n\n self.resin_loss_annual_constr = Constraint(expr=self.resin_loss_annual[self.t] == self.resin_vol[self.t] * self.resin_loss_frac_annual[self.t])\n\n self.cycle_time_constr = Constraint(expr=self.cycle_time[self.t] == (self.max_vol_treated[self.t] * resin_vol_L) / flow_out_L_hr)\n\n self.resin_area_constr = Constraint(expr=self.resin_area[self.t] == self.resin_vol[self.t] / self.resin_depth[self.t])\n\n self.column_area_constr = Constraint(expr=self.column_area[self.t] == 3.141592 * (self.column_diam[self.t] / 2) ** 2)\n\n self.num_columns_constr = Constraint(expr=self.num_columns[self.t] == self.resin_area[self.t] / self.column_area[self.t])\n\n self.flow_per_col_constr = Constraint(expr=self.flow_per_column[self.t] == flow_out_m3_hr / self.num_columns[self.t])\n\n self.resin_per_col_constr = Constraint(expr=self.resin_per_column[self.t] == self.resin_vol[self.t] / self.num_columns[self.t])\n\n self.loading_rate_constr1 = Constraint(expr=self.loading_rate[self.t] == self.flow_per_column[self.t] / self.column_area[self.t])\n self.loading_rate_constr2 = Constraint(expr=self.loading_rate[self.t] == self.sfr[self.t] * self.resin_depth[self.t])\n\n self.pressure_drop_constr = Constraint(expr=self.pressure_drop[self.t] == (8.28E-04 * self.loading_rate[self.t] ** 2 + 0.173 * self.loading_rate[self.t] + 0.609) * self.resin_depth[self.t]) # Curve for 20C temperatuer\n\n self.column_h_constr = Constraint(expr=self.column_h[self.t] == self.resin_depth[self.t] + self.bed_expansion_h[self.t] + self.distributor_h[self.t] + self.underdrain_h[self.t])\n\n self.column_vol_constr = Constraint(expr=self.column_vol[self.t] == 3.14159 * (self.column_diam[self.t] / 2) ** 2 * self.column_h[self.t])\n\n self.ebct_constr = Constraint(expr=self.ebct[self.t] == (self.resin_depth[self.t] / self.loading_rate[self.t]) * 60)\n\n #### REGEN CONSTRAINTS\n\n self.regen_density_constr = Constraint(expr=self.regen_density[self.t] == 994.34 + 761.65 * self.regen_ww[self.t]) # kg Nacl / m3 resin\n\n self.regen_conc_constr = Constraint(expr=self.regen_conc[self.t] == self.regen_ww[self.t] * self.regen_density[self.t])\n\n self.regen_vol_constr = Constraint(expr=self.regen_vol[self.t] == self.regen_dose[self.t] / self.regen_conc[self.t]) # m3 regen soln / m3 resin\n\n self.num_regen_per_column_annual_constr = Constraint(expr=self.num_regen_per_column_annual[self.t] == 8760 / self.cycle_time[self.t]) # numerator is hours per year\n\n self.salt_per_regen_per_column_constr = Constraint(expr=self.salt_per_regen_per_column[self.t] == self.resin_per_column[self.t] * self.regen_dose[self.t])\n\n self.salt_per_col_annual_constr = Constraint(expr=self.salt_per_column_annual[self.t] == self.num_regen_per_column_annual[self.t] * self.salt_per_regen_per_column[self.t]) # kg / year per column\n\n self.salt_total_annual_constr = Constraint(expr=self.salt_total_annual[self.t] == self.salt_per_column_annual[self.t] * self.num_columns[self.t]) # kg / year\n\n self.salt_dose_constr = Constraint(expr=self.salt_dose[self.t] == self.salt_total_annual[self.t] / flow_out_m3_yr)\n\n self.regen_soln_per_col_constr = Constraint(expr=self.regen_soln_per_column[self.t] == self.resin_per_column[self.t] * self.regen_vol[self.t])\n\n self.regen_soln_per_col_annual_constr = Constraint(expr=self.regen_soln_per_column_annual[self.t] == self.regen_soln_per_column[self.t] * self.num_regen_per_column_annual[self.t])\n\n self.regen_soln_annual_constr = Constraint(expr=self.regen_soln_annual[self.t] == self.regen_soln_per_column_annual[self.t] * self.num_columns[self.t])\n\n self.regen_time_per_col_constr = Constraint(expr=self.regen_time_per_column[self.t] == self.ebct[self.t] * self.regen_vol[self.t])\n\n self.total_regen_time_constr = Constraint(expr=self.total_regen_time[self.t] == self.regen_time_per_column[self.t] + self.rinse_time_per_column[self.t] + self.bw_time[self.t])\n\n self.regen_flow_constr = Constraint(expr=self.regen_flow[self.t] == self.column_vol[self.t] / self.regen_time_per_column[self.t])\n\n ##### BW CONSTRAINTS\n\n self.bed_exp_constr = Constraint(expr=self.bed_expansion[self.t] == -1.35E-3 * self.bw_rate[self.t] ** 2 + 1.02E-1 * self.bw_rate[self.t] - 1.23E-2)\n\n self.bed_exp_h_constr = Constraint(expr=self.bed_expansion_h[self.t] == self.resin_depth[self.t] * self.bed_expansion[self.t])\n\n self.bw_flow_constr = Constraint(expr=self.bw_flow[self.t] == self.column_vol[self.t] / self.bw_time[self.t])\n\n ##### RINSE CONSTRAINTS\n\n self.rinse_vol_per_column_constr = Constraint(expr=self.rinse_vol_per_column[self.t] == self.resin_per_column[self.t] * self.rinse_bv[self.t])\n\n self.rinse_vol_per_col_annual_constr = Constraint(expr=self.rinse_vol_per_column_annual[self.t] == self.rinse_vol_per_column[self.t] * self.num_regen_per_column_annual[self.t])\n\n self.rinse_time_per_col_constr = Constraint(expr=self.rinse_time_per_column[self.t] == self.ebct[self.t] * self.rinse_bv[self.t])\n\n self.rinse_flow_constr = Constraint(expr=self.rinse_flow[self.t] == self.column_vol[self.t] / self.rinse_time_per_column[self.t])\n\n ##### WATER RECOVERY, CHEM DICT, AND CONSTITUENT REMOVAL\n\n self.wr_constr = Constraint(expr=self.water_recovery[self.t] == 1 - (self.total_regen_time[self.t] / ((self.cycle_time[self.t] * 60) + self.total_regen_time[self.t])))\n\n self.chem_dict = {\n 'Sodium_Chloride': self.salt_dose[self.t]\n }\n\n self.del_component(self.component_removal_equation)\n\n self.ix_component_removal = ConstraintList()\n for c in self.config.property_package.component_list:\n if c in self.cons:\n self.ix_component_removal.add(self.frac_removed[self.t, c] * self.flow_vol_in[self.t] * self.conc_mass_in[self.t, c] ==\n self.flow_vol_waste[self.t] * self.conc_mass_waste[self.t, c])\n else:\n self.ix_component_removal.add(self.removal_fraction[self.t, c] * self.flow_vol_in[self.t] * self.conc_mass_in[self.t, c] ==\n self.flow_vol_waste[self.t] * self.conc_mass_waste[self.t, c])\n\n def sac(self, unit_params):\n '''\n Function for Strong-Acid Cation Exchange Model\n :param unit_params:\n :return:\n '''\n\n ### REGEN VARIABLES\n\n time = self.flowsheet().config.time\n\n ### REGEN VARIABLES\n\n self.regen_dose = Var(time,\n initialize=300,\n domain=NonNegativeReals,\n units=pyunits.kg / pyunits.m ** 3,\n bounds=(80, 500),\\\n doc='NaCl dose required for regeneration [kg/m3]')\n\n self.regen_rate = Var(time,\n initialize=4,\n domain=NonNegativeReals,\n bounds=(2, 5),\n doc='Regeneration rate [BV/hr]')\n\n self.regen_density = Var(time,\n initialize=1000,\n domain=NonNegativeReals,\n units=pyunits.kg / pyunits.m ** 3,\n bounds=(990, 1200),\n doc='Density of NaCl regen solution [kg/m3]')\n\n self.regen_ww = Var(time,\n initialize=0.1,\n domain=NonNegativeReals,\n bounds=(0.015, 0.26),\n doc='Strength of NaCl solution w/w [kg NaCl/kg soln]')\n\n self.regen_conc = Var(time,\n initialize=110,\n domain=NonNegativeReals,\n units=pyunits.kg / pyunits.m ** 3,\n doc='Concentration of regen solution [kg/m3]')\n\n self.regen_vol = Var(time,\n initialize=2,\n domain=NonNegativeReals,\n doc='m3 of regen solution per m3 resin')\n\n self.regen_soln_per_column = Var(time,\n initialize=50,\n domain=NonNegativeReals,\n units=pyunits.m ** 3,\n doc='Regen solution used per column [m3/column]')\n\n self.regen_soln_per_column_annual = Var(time,\n initialize=1E3,\n domain=NonNegativeReals,\n units=pyunits.m ** 3 / pyunits.year,\n doc='Annual regen used per column [m3/year]')\n\n self.regen_soln_annual = Var(time,\n initialize=1E5,\n domain=NonNegativeReals,\n units=pyunits.m ** 3 / pyunits.year,\n doc='Total volume regen solution used [m3/year]')\n\n self.regen_time_per_column = Var(time,\n initialize=5,\n domain=NonNegativeReals,\n units=pyunits.min,\n doc='Regen time per column [min]')\n\n self.regen_flow = Var(time,\n initialize=10,\n domain=NonNegativeReals,\n units=pyunits.m ** 3 / pyunits.min,\n doc='Regeneration flow rate [m3/min]')\n\n self.num_regen_per_column_annual = Var(time,\n initialize=200,\n domain=NonNegativeReals,\n doc='Number of regen cycles per year')\n\n self.salt_per_regen_per_column = Var(time,\n initialize=5E3,\n domain=NonNegativeReals,\n doc='Number of regen cycles per year')\n\n self.salt_per_column_annual = Var(time,\n initialize=1E5,\n domain=NonNegativeReals,\n units=pyunits.kg / pyunits.year,\n doc='Mass of salt per column per year [kg/yr]')\n\n self.salt_total_annual = Var(time,\n initialize=1E6,\n domain=NonNegativeReals,\n units=pyunits.kg / pyunits.year,\n doc='Mass of salt per year [kg/yr]')\n\n self.salt_dose = Var(time,\n initialize=0.1,\n domain=NonNegativeReals,\n units=pyunits.kg / pyunits.m ** 3,\n doc='Salt dose for system [kg/m3]')\n\n self.total_regen_time = Var(time,\n initialize=30,\n units=pyunits.min,\n domain=NonNegativeReals,\n doc='Total regeneration cycle time [min]')\n\n self.regen_dose.fix(300)\n\n try:\n self.regen_ww.fix(unit_params['regen_ww'])\n except KeyError:\n self.regen_ww.fix(0.1)\n\n ### BACKWASH VARIABLES\n\n self.bw_rate = Var(time,\n initialize=5,\n domain=NonNegativeReals,\n units=pyunits.m / pyunits.hour,\n bounds=(4.5, 6.5),\n doc='Backwash rate [m/hr]')\n\n self.bw_time = Var(time,\n initialize=6,\n domain=NonNegativeReals,\n units=pyunits.minute,\n bounds=(4, 15),\n doc='Backwash time [min]')\n\n self.bw_flow = Var(time,\n initialize=5,\n domain=NonNegativeReals,\n units=pyunits.m ** 3 / pyunits.minute,\n doc='Backwash flow rate [m3/min]')\n\n self.bed_expansion = Var(time,\n initialize=0.5,\n domain=NonNegativeReals,\n units=pyunits.dimensionless,\n bounds=(0.4, 0.6),\n doc='Resin bed expansion during backwash [%]')\n\n self.bed_expansion_h = Var(time,\n # initialize=0.5,\n domain=NonNegativeReals,\n units=pyunits.m,\n bounds=(0.1, 3),\n doc='Resin bed expansion during backwash [m]')\n\n self.bw_time.fix(6)\n\n ### RINSE VARIABLES\n\n self.rinse_bv = Var(time,\n initialize=5,\n domain=NonNegativeReals,\n bounds=(2, 5),\n doc='Number of bed volumes for rinse step [BV]')\n\n self.rinse_vol_per_column = Var(time,\n initialize=150,\n domain=NonNegativeReals,\n units=pyunits.m ** 3,\n doc='Rinse volume per column [m3/col]')\n\n self.rinse_vol_per_column_annual = Var(time,\n initialize=5E3,\n domain=NonNegativeReals,\n units=pyunits.m ** 3 / pyunits.year,\n doc='Rinse volume per column [m3/yr]')\n\n self.rinse_time_per_column = Var(time,\n initialize=4,\n domain=NonNegativeReals,\n units=pyunits.min,\n doc='Rinse time per column [min]')\n\n self.rinse_flow = Var(time,\n initialize=2,\n domain=NonNegativeReals,\n units=pyunits.m ** 3 / pyunits.min,\n doc='Rinse step flow rate [m3/min]')\n\n self.rinse_bv.fix(3)\n\n ### RESIN AND FLOW VARIABLES\n\n ix_df = self.ix_df = pd.read_csv('data/ix_sac.csv', index_col='constituent')\n self.cons = [c for c in self.config.property_package.component_list if c in ix_df.index]\n ix_df = self.ix_df = ix_df.loc[self.cons].copy()\n self.sep_factor_dict = ix_df.to_dict()['sep_factor']\n self.meq_conv_dict = ix_df.to_dict()['meq']\n\n try:\n self.target = unit_params['target']\n except KeyError:\n self.cons_df = self.source_df.loc[[c for c in self.cons if c != 'sodium']].copy()\n self.cons_df['meq_L'] = [(self.cons_df.loc[c].value * 1E3) / self.meq_conv_dict[c] for c in self.cons if c != 'sodium']\n self.target = self.cons_df.meq_L.idxmax()\n\n for k, v in self.sep_factor_dict.items():\n if v > self.sep_factor_dict[self.target]:\n self.sep_factor_dict[k] = 0.99 * self.sep_factor_dict[self.target]\n\n self.sep_factor = Param(self.cons,\n initialize=self.sep_factor_dict)\n\n self.meq_conv = Param(self.cons,\n initialize=self.meq_conv_dict)\n\n self.target_removal = Var(time,\n initialize=1,\n domain=NonNegativeReals,\n bounds=(0.0001, 1),\n doc='Removal fraction for target compound')\n\n self.sfr = Var(time,\n initialize=30,\n domain=NonNegativeReals,\n bounds=(6, 50),\n doc='Service flow rate [BV/hr]')\n\n self.loading_rate = Var(time,\n initialize=20,\n domain=NonNegativeReals,\n bounds=(10, 40),\n units=pyunits.m / pyunits.hr,\n doc='Column loading rate (superficial velocity) [m/hr]')\n\n self.cycle_time = Var(time,\n initialize=100,\n domain=NonNegativeReals,\n units=pyunits.hr,\n doc='Service cycle time [hr]')\n\n self.ebct = Var(time,\n initialize=1.1,\n domain=NonNegativeReals,\n units=pyunits.min,\n doc='Empty Bed Contact Time [min]')\n\n self.mg_L = Var(time,\n self.cons,\n initialize=1,\n domain=NonNegativeReals,\n doc='Influent concentration in mg/L')\n\n self.meq_L = Var(time,\n self.cons,\n initialize=0.1,\n domain=NonNegativeReals,\n doc='Influent concentration in meq/L')\n\n self.mass_in = Var(time,\n self.cons,\n initialize=200,\n domain=NonNegativeReals,\n doc='Influent mass [eq]')\n\n self.mass_removed = Var(time,\n self.cons,\n initialize=10,\n domain=NonNegativeReals,\n doc='Mass removed [eq]')\n\n self.frac_removed = Var(time,\n self.cons,\n initialize=0.8,\n domain=NonNegativeReals,\n doc='Fraction removed [%]')\n\n self.denom_resin = Var(time,\n initialize=1,\n domain=NonNegativeReals)\n\n self.denom_aq = Var(time,\n initialize=1,\n domain=NonNegativeReals)\n\n self.resin_conc = Var(time,\n self.cons,\n initialize=0.1,\n domain=NonNegativeReals,\n doc='Resin phase concentration of each ion [eq/L resin]')\n\n self.max_vol_treated = Var(time,\n initialize=5E3,\n domain=NonNegativeReals,\n bounds=(100, 1E6),\n units=pyunits.L / pyunits.L,\n doc='Max volume of water treated before breakthrough [L water/L resin]')\n\n self.resin_capacity = Var(time,\n initialize=1.7,\n domain=NonNegativeReals,\n bounds=(1.6, 2.2),\n doc='Resin capacity [eq/L]')\n\n self.resin_vol = Var(time,\n # initialize=100,\n domain=NonNegativeReals,\n units=pyunits.m ** 3,\n doc='Resin volume needed [m3]')\n\n self.resin_area = Var(time,\n initialize=100,\n domain=NonNegativeReals,\n units=pyunits.m ** 2,\n doc='Resin cross-sectional area needed [m2]')\n\n self.resin_depth = Var(time,\n initialize=1.5,\n domain=NonNegativeReals,\n bounds=(0.75, 3),\n units=pyunits.m,\n doc='Resin bed depth [m]')\n\n self.resin_depth_to_column_diam_ratio = Var(time,\n initialize=1,\n domain=NonNegativeReals,\n bounds=(0.6, 1.6),\n units=pyunits.dimensionless,\n doc='Ratio of resin depth to column height')\n\n self.resin_per_column = Var(time,\n initialize=15,\n domain=NonNegativeReals,\n units=pyunits.m ** 3,\n doc='Resin per column [m3]')\n\n self.resin_loss_frac_annual = Var(time,\n initialize=0.045,\n domain=NonNegativeReals,\n bounds=(3.75, 5.25),\n doc='Fraction of resin replaced per year [%]')\n\n self.resin_loss_annual = Var(time,\n initialize=20,\n domain=NonNegativeReals,\n units=pyunits.m ** 3,\n doc='Resin replaced per year [m3]')\n\n #### COLUMN VARIABLES\n\n self.column_h = Var(time,\n initialize=2,\n domain=NonNegativeReals,\n units=pyunits.m,\n bounds=(1, 16),\n doc='Column height [m]')\n\n self.column_diam = Var(time,\n initialize=2,\n domain=NonNegativeReals,\n units=pyunits.m,\n bounds=(1, 4),\n doc='Column diameter [m]')\n\n self.column_area = Var(time,\n initialize=15,\n domain=NonNegativeReals,\n units=pyunits.m ** 2,\n doc='Column cross-sectional area [m2]')\n\n if self.pv_material == 'fiberglass':\n self.column_vol = Var(time,\n initialize=2,\n domain=NonNegativeReals,\n bounds=(0.5, 4),\n units=pyunits.m ** 3,\n doc='Column volume [m3]')\n\n else:\n self.column_vol = Var(time,\n initialize=35,\n domain=NonNegativeReals,\n bounds=(0.5, 25),\n units=pyunits.m ** 3,\n doc='Column volume [m3]')\n\n self.num_columns = Var(time,\n initialize=2,\n domain=NonNegativeReals,\n bounds=(1, 1E5),\n units=pyunits.dimensionless,\n doc='Number of columns in parallel')\n\n self.underdrain_h = Var(time,\n initialize=0.5,\n domain=NonNegativeReals,\n units=pyunits.m,\n doc='Underdrain height [m]')\n\n self.distributor_h = Var(time,\n initialize=1,\n domain=NonNegativeReals,\n units=pyunits.m,\n doc='Distributor height [m]')\n\n self.flow_per_column = Var(time,\n initialize=250,\n domain=NonNegativeReals,\n units=pyunits.m ** 3 / pyunits.hr,\n doc='Flow per column [m3/hr]')\n\n self.pressure_drop = Var(time,\n initialize=14,\n domain=NonNegativeReals,\n units=pyunits.psi,\n bounds=(0, 25),\n doc='Pressure drop across column [psi]')\n\n self.resin_capacity.fix(1.7)\n # self.sfr.fix(30)\n self.loading_rate.fix(20)\n self.underdrain_h.fix(0.5)\n self.distributor_h.fix(1)\n self.resin_loss_frac_annual.fix(0.045)\n # self.column_diam.fix(2.5)\n\n try:\n self.target_removal = unit_params['target_removal']\n except KeyError:\n self.target_removal.fix(1)\n\n flow_out_m3_hr = pyunits.convert(self.flow_vol_out[self.t], to_units=pyunits.m ** 3 / pyunits.hr)\n flow_out_m3_yr = pyunits.convert(self.flow_vol_out[self.t], to_units=pyunits.m ** 3 / pyunits.year)\n flow_out_L_hr = pyunits.convert(self.flow_vol_out[self.t], to_units=pyunits.L / pyunits.hr)\n\n ############################# CONSTRAINTS START\n #### RESIN AND PERFORMANCE CONSTRAINTS\n\n self.mg_L_constr = ConstraintList()\n self.meq_L_constr = ConstraintList()\n self.resin_conc_constr = ConstraintList()\n self.mass_in_constr = ConstraintList()\n self.mass_removed_constr = ConstraintList()\n self.frac_removed_constr = ConstraintList()\n\n for c in self.cons:\n self.mg_L_constr.add(self.mg_L[self.t, c] == (self.conc_mass_in[self.t, c] * 1E3))\n self.meq_L_constr.add(self.meq_L[self.t, c] == self.mg_L[self.t, c] / self.meq_conv[c])\n self.resin_conc_constr.add(self.resin_conc[self.t, c] == (self.resin_capacity[self.t] * self.sep_factor[c] * self.meq_L[self.t, c]) /\n self.denom_resin[self.t])\n self.mass_in_constr.add(self.mass_in[self.t, c] == self.meq_L[self.t, c] * flow_out_m3_hr * self.cycle_time[self.t] * 1E-3)\n self.mass_removed_constr.add(self.mass_removed[self.t, c] == (self.resin_conc[self.t, c] / self.max_vol_treated[self.t]) * flow_out_m3_hr * self.cycle_time[self.t])\n self.frac_removed_constr.add(self.frac_removed[self.t, c] == 0.99 * (self.mass_removed[self.t, c] / self.mass_in[self.t, c]))\n\n self.denom_resin_constr = Constraint(expr=self.denom_resin[self.t] == sum(self.meq_L[self.t, c] * self.sep_factor[c] for c in self.cons))\n self.denom_aq_constr = Constraint(expr=self.denom_aq[self.t] == sum(self.resin_conc[self.t, c] / self.sep_factor[c] for c in self.cons))\n\n self.max_vol_treated_constr = Constraint(expr=self.max_vol_treated[self.t] == (self.resin_conc[self.t, self.target] * 1E3) /\n (self.meq_L[self.t, self.target] * self.target_removal[self.t]))\n\n self.resin_vol_constr = Constraint(expr=self.resin_vol[self.t] == flow_out_m3_hr / self.sfr[self.t])\n resin_vol_L = pyunits.convert(self.resin_vol[self.t], to_units=pyunits.L)\n\n self.resin_depth_to_column_diam_ratio_constr = Constraint(expr=self.resin_depth_to_column_diam_ratio[self.t] == self.resin_depth[self.t] / self.column_diam[self.t])\n\n self.resin_loss_annual_constr = Constraint(expr=self.resin_loss_annual[self.t] == self.resin_vol[self.t] * self.resin_loss_frac_annual[self.t])\n\n self.cycle_time_constr = Constraint(expr=self.cycle_time[self.t] == (self.max_vol_treated[self.t] * resin_vol_L) / flow_out_L_hr)\n\n self.resin_area_constr = Constraint(expr=self.resin_area[self.t] == self.resin_vol[self.t] / self.resin_depth[self.t])\n\n self.column_area_constr = Constraint(expr=self.column_area[self.t] == 3.141592 * (self.column_diam[self.t] / 2) ** 2)\n\n self.num_columns_constr = Constraint(expr=self.num_columns[self.t] == self.resin_area[self.t] / self.column_area[self.t])\n\n self.flow_per_col_constr = Constraint(expr=self.flow_per_column[self.t] == flow_out_m3_hr / self.num_columns[self.t])\n\n self.resin_per_col_constr = Constraint(expr=self.resin_per_column[self.t] == self.resin_vol[self.t] / self.num_columns[self.t])\n\n self.loading_rate_constr1 = Constraint(expr=self.loading_rate[self.t] == self.flow_per_column[self.t] / self.column_area[self.t])\n self.loading_rate_constr2 = Constraint(expr=self.loading_rate[self.t] == self.sfr[self.t] * self.resin_depth[self.t])\n\n self.pressure_drop_constr = Constraint(expr=self.pressure_drop[self.t] == (8.28E-04 * self.loading_rate[self.t] ** 2 + 0.173 * self.loading_rate[self.t] + 0.609) * self.resin_depth[self.t]) # Curve for 20C temperatuer\n\n self.column_h_constr = Constraint(expr=self.column_h[self.t] == self.resin_depth[self.t] + self.bed_expansion_h[self.t] + self.distributor_h[self.t] + self.underdrain_h[self.t])\n\n self.column_vol_constr = Constraint(expr=self.column_vol[self.t] == 3.14159 * (self.column_diam[self.t] / 2) ** 2 * self.column_h[self.t])\n\n self.ebct_constr = Constraint(expr=self.ebct[self.t] == (self.resin_depth[self.t] / self.loading_rate[self.t]) * 60)\n\n #### REGEN CONSTRAINTS\n\n self.regen_density_constr = Constraint(expr=self.regen_density[self.t] == 994.34 + 761.65 * self.regen_ww[self.t]) # kg Nacl / m3 resin\n\n self.regen_conc_constr = Constraint(expr=self.regen_conc[self.t] == self.regen_ww[self.t] * self.regen_density[self.t])\n\n self.regen_vol_constr = Constraint(expr=self.regen_vol[self.t] == self.regen_dose[self.t] / self.regen_conc[self.t]) # m3 regen soln / m3 resin\n\n self.num_regen_per_column_annual_constr = Constraint(expr=self.num_regen_per_column_annual[self.t] == 8760 / self.cycle_time[self.t]) # numerator is hours per year\n\n self.salt_per_regen_per_column_constr = Constraint(expr=self.salt_per_regen_per_column[self.t] == self.resin_per_column[self.t] * self.regen_dose[self.t])\n\n self.salt_per_col_annual_constr = Constraint(expr=self.salt_per_column_annual[self.t] == self.num_regen_per_column_annual[self.t] * self.salt_per_regen_per_column[self.t]) # kg / year per column\n\n self.salt_total_annual_constr = Constraint(expr=self.salt_total_annual[self.t] == self.salt_per_column_annual[self.t] * self.num_columns[self.t]) # kg / year\n\n self.salt_dose_constr = Constraint(expr=self.salt_dose[self.t] == self.salt_total_annual[self.t] / flow_out_m3_yr)\n\n self.regen_soln_per_col_constr = Constraint(expr=self.regen_soln_per_column[self.t] == self.resin_per_column[self.t] * self.regen_vol[self.t])\n\n self.regen_soln_per_col_annual_constr = Constraint(expr=self.regen_soln_per_column_annual[self.t] == self.regen_soln_per_column[self.t] * self.num_regen_per_column_annual[self.t])\n\n self.regen_soln_annual_constr = Constraint(expr=self.regen_soln_annual[self.t] == self.regen_soln_per_column_annual[self.t] * self.num_columns[self.t])\n\n self.regen_time_per_col_constr = Constraint(expr=self.regen_time_per_column[self.t] == self.ebct[self.t] * self.regen_vol[self.t])\n\n self.total_regen_time_constr = Constraint(expr=self.total_regen_time[self.t] == self.regen_time_per_column[self.t] + self.rinse_time_per_column[self.t] + self.bw_time[self.t])\n\n self.regen_flow_constr = Constraint(expr=self.regen_flow[self.t] == self.column_vol[self.t] / self.regen_time_per_column[self.t])\n\n ##### BW CONSTRAINTS\n\n self.bed_exp_constr = Constraint(expr=self.bed_expansion[self.t] == -1.35E-3 * self.bw_rate[self.t] ** 2 + 1.02E-1 * self.bw_rate[self.t] - 1.23E-2)\n\n self.bed_exp_h_constr = Constraint(expr=self.bed_expansion_h[self.t] == self.resin_depth[self.t] * self.bed_expansion[self.t])\n\n self.bw_flow_constr = Constraint(expr=self.bw_flow[self.t] == self.column_vol[self.t] / self.bw_time[self.t])\n\n ##### RINSE CONSTRAINTS\n\n self.rinse_vol_per_column_constr = Constraint(expr=self.rinse_vol_per_column[self.t] == self.resin_per_column[self.t] * self.rinse_bv[self.t])\n\n self.rinse_vol_per_col_annual_constr = Constraint(expr=self.rinse_vol_per_column_annual[self.t] == self.rinse_vol_per_column[self.t] * self.num_regen_per_column_annual[self.t])\n\n self.rinse_time_per_col_constr = Constraint(expr=self.rinse_time_per_column[self.t] == self.ebct[self.t] * self.rinse_bv[self.t])\n\n self.rinse_flow_constr = Constraint(expr=self.rinse_flow[self.t] == self.column_vol[self.t] / self.rinse_time_per_column[self.t])\n\n ##### WATER RECOVERY, CHEM DICT, AND CONSTITUENT REMOVAL\n\n self.wr_constr = Constraint(expr=self.water_recovery[self.t] == 1 - (self.total_regen_time[self.t] / ((self.cycle_time[self.t] * 60) + self.total_regen_time[self.t])))\n\n self.chem_dict = {\n 'Sodium_Chloride': self.salt_dose[self.t]\n }\n\n self.del_component(self.component_removal_equation)\n\n self.ix_component_removal = ConstraintList()\n for c in self.config.property_package.component_list:\n if c in self.cons:\n self.ix_component_removal.add(self.frac_removed[self.t, c] * self.flow_vol_in[self.t] * self.conc_mass_in[self.t, c] ==\n self.flow_vol_waste[self.t] * self.conc_mass_waste[self.t, c])\n else:\n self.ix_component_removal.add(self.removal_fraction[self.t, c] * self.flow_vol_in[self.t] * self.conc_mass_in[self.t, c] ==\n self.flow_vol_waste[self.t] * self.conc_mass_waste[self.t, c])\n\n def get_costing(self, unit_params=None, year=None):\n '''\n Initialize the unit in WaterTAP3.\n '''\n financials.create_costing_block(self, basis_year, tpec_or_tic)\n time = self.flowsheet().config.time\n self.t = time.first()\n self.units_meta = self.config.property_package.get_metadata().get_derived_units\n\n self.mode = unit_params['mode']\n self.source_df = self.parent_block().source_df\n self.parent_block().has_ix = True\n try:\n self.pv_material = unit_params['pv_material']\n except KeyError:\n self.pv_material = 'carbon_w_plastic_internals'\n\n\n\n if self.mode == 'sac':\n self.resin_dict = {\n 'polystyrenic_macro': 3680,\n 'polystyrenic_gel': 6240,\n } # cost of resin per m3, adapted to $/m3 from EPA models\n\n try:\n self.resin_type = unit_params['resin_type']\n except KeyError:\n self.resin_type = 'polystyrenic_macro'\n self.sac(unit_params)\n\n if self.mode == 'sba':\n self.resin_dict = {\n 'styrenic_gel_1': 5214,\n 'styrenic_gel_2': 6116,\n 'styrenic_macro_1': 7298,\n 'styrenic_macro_2': 7810,\n 'polyacrylic': 8658,\n 'nitrate': 6116\n } # cost of resin per m3, adapted to $/m3 from EPA models\n try:\n self.resin_type = unit_params['resin_type']\n except KeyError:\n self.resin_type = 'styrenic_gel_1'\n self.sba(unit_params)\n\n\n\n self.costing.fixed_cap_inv_unadjusted = Expression(expr=self.fixed_cap(unit_params),\n doc='Unadjusted fixed capital investment')\n self.electricity = Expression(expr=self.elect(),\n doc='Electricity intensity [kwh/m3]')\n\n self.costing.other_var_cost = (self.resin_unit_cap[self.t] * self.resin_loss_annual[self.t]) * 1E-6\n financials.get_complete_costing(self.costing)" ]

[ [ "pandas.read_csv" ] ]

mateus2810/atividadesIa

[ "0ffc816c962889fb9e0b9635692d616e46a0d0c5" ]

[ "atividade2/RetornarVerticesAdjacentes.py" ]

[ "#Questão 7 - Retornar os vertes adjacentes\n\nimport numpy as np\n\nmatrixIa = [[0,5,0,0,15,2], [5,0,0,9,22,4], [0,0,0,13,1,0], [9,0,12,0,0,6], [15,22,1,0,0,0], [2,4,0,6,0,0]]\n#Mostrar os vertes adjacentes ]\n\nprint(np.matrix(matrixIa))\n" ]

[ [ "numpy.matrix" ] ]

wbernoudy/dimod

[ "c39677b4a743574dc795bc140dce703abd61087b" ]

[ "dimod/utilities.py" ]

[ "# Copyright 2018 D-Wave Systems Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport copy\nimport os\nimport itertools\n\nfrom functools import reduce\n\nimport numpy as np\n\n__all__ = ['ising_energy',\n 'qubo_energy',\n 'ising_to_qubo',\n 'qubo_to_ising',\n 'child_structure_dfs',\n 'get_include',\n ]\n\n\ndef ising_energy(sample, h, J, offset=0.0):\n \"\"\"Calculate the energy for the specified sample of an Ising model.\n\n Energy of a sample for a binary quadratic model is defined as a sum, offset\n by the constant energy offset associated with the model, of\n the sample multipled by the linear bias of the variable and\n all its interactions. For an Ising model,\n\n .. math::\n\n E(\\mathbf{s}) = \\sum_v h_v s_v + \\sum_{u,v} J_{u,v} s_u s_v + c\n\n where :math:`s_v` is the sample, :math:`h_v` is the linear bias, :math:`J_{u,v}`\n the quadratic bias (interactions), and :math:`c` the energy offset.\n\n Args:\n sample (dict[variable, spin]):\n Sample for a binary quadratic model as a dict of form {v: spin, ...},\n where keys are variables of the model and values are spins (either -1 or 1).\n h (dict[variable, bias]):\n Linear biases as a dict of the form {v: bias, ...}, where keys are variables of\n the model and values are biases.\n J (dict[(variable, variable), bias]):\n Quadratic biases as a dict of the form {(u, v): bias, ...}, where keys\n are 2-tuples of variables of the model and values are quadratic biases\n associated with the pair of variables (the interaction).\n offset (numeric, optional, default=0):\n Constant offset to be applied to the energy. Default 0.\n\n Returns:\n float: The induced energy.\n\n Notes:\n No input checking is performed.\n\n Examples:\n This example calculates the energy of a sample representing two down spins for\n an Ising model of two variables that have positive biases of value 1 and\n are positively coupled with an interaction of value 1.\n\n >>> sample = {1: -1, 2: -1}\n >>> h = {1: 1, 2: 1}\n >>> J = {(1, 2): 1}\n >>> dimod.ising_energy(sample, h, J, 0.5)\n -0.5\n\n References\n ----------\n\n `Ising model on Wikipedia <https://en.wikipedia.org/wiki/Ising_model>`_\n\n \"\"\"\n # add the contribution from the linear biases\n for v in h:\n offset += h[v] * sample[v]\n\n # add the contribution from the quadratic biases\n for v0, v1 in J:\n offset += J[(v0, v1)] * sample[v0] * sample[v1]\n\n return offset\n\n\ndef qubo_energy(sample, Q, offset=0.0):\n \"\"\"Calculate the energy for the specified sample of a QUBO model.\n\n Energy of a sample for a binary quadratic model is defined as a sum, offset\n by the constant energy offset associated with the model, of\n the sample multipled by the linear bias of the variable and\n all its interactions. For a quadratic unconstrained binary optimization (QUBO)\n model,\n\n .. math::\n\n E(\\mathbf{x}) = \\sum_{u,v} Q_{u,v} x_u x_v + c\n\n where :math:`x_v` is the sample, :math:`Q_{u,v}`\n a matrix of biases, and :math:`c` the energy offset.\n\n Args:\n sample (dict[variable, spin]):\n Sample for a binary quadratic model as a dict of form {v: bin, ...},\n where keys are variables of the model and values are binary (either 0 or 1).\n Q (dict[(variable, variable), coefficient]):\n QUBO coefficients in a dict of form {(u, v): coefficient, ...}, where keys\n are 2-tuples of variables of the model and values are biases\n associated with the pair of variables. Tuples (u, v) represent interactions\n and (v, v) linear biases.\n offset (numeric, optional, default=0):\n Constant offset to be applied to the energy. Default 0.\n\n Returns:\n float: The induced energy.\n\n Notes:\n No input checking is performed.\n\n Examples:\n This example calculates the energy of a sample representing two zeros for\n a QUBO model of two variables that have positive biases of value 1 and\n are positively coupled with an interaction of value 1.\n\n >>> sample = {1: 0, 2: 0}\n >>> Q = {(1, 1): 1, (2, 2): 1, (1, 2): 1}\n >>> dimod.qubo_energy(sample, Q, 0.5)\n 0.5\n\n References\n ----------\n\n `QUBO model on Wikipedia <https://en.wikipedia.org/wiki/Quadratic_unconstrained_binary_optimization>`_\n\n \"\"\"\n for v0, v1 in Q:\n offset += sample[v0] * sample[v1] * Q[(v0, v1)]\n\n return offset\n\n\ndef ising_to_qubo(h, J, offset=0.0):\n \"\"\"Convert an Ising problem to a QUBO problem.\n\n Map an Ising model defined on spins (variables with {-1, +1} values) to quadratic\n unconstrained binary optimization (QUBO) formulation :math:`x' Q x` defined over\n binary variables (0 or 1 values), where the linear term is contained along the diagonal of Q.\n Return matrix Q that defines the model as well as the offset in energy between the two\n problem formulations:\n\n .. math::\n\n s' J s + h' s = offset + x' Q x\n\n See :meth:`~dimod.utilities.qubo_to_ising` for the inverse function.\n\n Args:\n h (dict[variable, bias]):\n Linear biases as a dict of the form {v: bias, ...}, where keys are variables of\n the model and values are biases.\n J (dict[(variable, variable), bias]):\n Quadratic biases as a dict of the form {(u, v): bias, ...}, where keys\n are 2-tuples of variables of the model and values are quadratic biases\n associated with the pair of variables (the interaction).\n offset (numeric, optional, default=0):\n Constant offset to be applied to the energy. Default 0.\n\n Returns:\n (dict, float): A 2-tuple containing:\n\n dict: QUBO coefficients.\n\n float: New energy offset.\n\n Examples:\n This example converts an Ising problem of two variables that have positive\n biases of value 1 and are positively coupled with an interaction of value 1\n to a QUBO problem and prints the resulting energy offset.\n\n >>> h = {1: 1, 2: 1}\n >>> J = {(1, 2): 1}\n >>> dimod.ising_to_qubo(h, J, 0.5)[1]\n -0.5\n\n \"\"\"\n # the linear biases are the easiest\n q = {(v, v): 2. * bias for v, bias in h.items()}\n\n # next the quadratic biases\n for (u, v), bias in J.items():\n if bias == 0.0:\n continue\n q[(u, v)] = 4. * bias\n q[(u, u)] = q.setdefault((u, u), 0) - 2. * bias\n q[(v, v)] = q.setdefault((v, v), 0) - 2. * bias\n\n # finally calculate the offset\n offset += sum(J.values()) - sum(h.values())\n\n return q, offset\n\n\ndef qubo_to_ising(Q, offset=0.0):\n \"\"\"Convert a QUBO problem to an Ising problem.\n\n Map a quadratic unconstrained binary optimization (QUBO) problem :math:`x' Q x`\n defined over binary variables (0 or 1 values), where the linear term is contained along\n the diagonal of Q, to an Ising model defined on spins (variables with {-1, +1} values).\n Return h and J that define the Ising model as well as the offset in energy\n between the two problem formulations:\n\n .. math::\n\n x' Q x = offset + s' J s + h' s\n\n See :meth:`~dimod.utilities.ising_to_qubo` for the inverse function.\n\n Args:\n Q (dict[(variable, variable), coefficient]):\n QUBO coefficients in a dict of form {(u, v): coefficient, ...}, where keys\n are 2-tuples of variables of the model and values are biases\n associated with the pair of variables. Tuples (u, v) represent interactions\n and (v, v) linear biases.\n offset (numeric, optional, default=0):\n Constant offset to be applied to the energy. Default 0.\n\n Returns:\n (dict, dict, float): A 3-tuple containing:\n\n dict: Linear coefficients of the Ising problem.\n\n dict: Quadratic coefficients of the Ising problem.\n\n float: New energy offset.\n\n Examples:\n This example converts a QUBO problem of two variables that have positive\n biases of value 1 and are positively coupled with an interaction of value 1\n to an Ising problem, and shows the new energy offset.\n\n >>> Q = {(1, 1): 1, (2, 2): 1, (1, 2): 1}\n >>> dimod.qubo_to_ising(Q, 0.5)[2]\n 1.75\n\n \"\"\"\n h = {}\n J = {}\n linear_offset = 0.0\n quadratic_offset = 0.0\n\n for (u, v), bias in Q.items():\n if u == v:\n if u in h:\n h[u] += .5 * bias\n else:\n h[u] = .5 * bias\n linear_offset += bias\n\n else:\n if bias != 0.0:\n J[(u, v)] = .25 * bias\n\n if u in h:\n h[u] += .25 * bias\n else:\n h[u] = .25 * bias\n\n if v in h:\n h[v] += .25 * bias\n else:\n h[v] = .25 * bias\n\n quadratic_offset += bias\n\n offset += .5 * linear_offset + .25 * quadratic_offset\n\n return h, J, offset\n\n\ndef resolve_label_conflict(mapping, existing, old_labels=None, new_labels=None):\n \"\"\"Resolve a self-labeling conflict by creating an intermediate labeling.\n\n Args:\n mapping (dict):\n A dict mapping the current variable labels to new ones.\n\n existing (set-like):\n The existing labels.\n\n old_labels (set, optional, default=None):\n The keys of mapping. Can be passed in for performance reasons. These are not checked.\n\n new_labels (set, optional, default=None):\n The values of mapping. Can be passed in for performance reasons. These are not checked.\n\n Returns:\n tuple: A 2-tuple containing:\n\n dict: A map from the keys of mapping to an intermediate labeling\n\n dict: A map from the intermediate labeling to the values of mapping.\n\n \"\"\"\n\n if old_labels is None:\n old_labels = set(mapping)\n if new_labels is None:\n new_labels = set(mapping.values())\n\n # counter will be used to generate the intermediate labels, as an easy optimization\n # we start the counter with a high number because often variables are labeled by\n # integers starting from 0\n counter = itertools.count(2 * len(mapping))\n\n old_to_intermediate = {}\n intermediate_to_new = {}\n\n for old, new in mapping.items():\n if old == new:\n # we can remove self-labels\n continue\n\n if old in new_labels or new in old_labels:\n\n # try to get a new unique label\n lbl = next(counter)\n while lbl in new_labels or lbl in old_labels or lbl in existing:\n lbl = next(counter)\n\n # add it to the mapping\n old_to_intermediate[old] = lbl\n intermediate_to_new[lbl] = new\n\n else:\n old_to_intermediate[old] = new\n # don't need to add it to intermediate_to_new because it is a self-label\n\n return old_to_intermediate, intermediate_to_new\n\n\ndef iter_safe_relabels(mapping, existing):\n \"\"\"Iterator over \"safe\" intermediate relabelings.\n\n Args:\n mapping (dict):\n A map from old labels to new.\n\n existing (set):\n A container of existing labels.\n\n Yields:\n dict: A \"safe\" relabelling.\n\n \"\"\"\n\n # put the new labels into a set for fast lookup, also ensures that the\n # values are valid labels\n try:\n new_labels = set(mapping.values())\n except TypeError:\n raise ValueError(\"mapping targets must be hashable objects\")\n\n old_labels = mapping.keys()\n\n for v in new_labels:\n if v in existing and v not in old_labels:\n msg = (\"A variable cannot be relabeled {!r} without also \"\n \"relabeling the existing variable of the same name\")\n raise ValueError(msg.format(v))\n\n if any(v in new_labels for v in old_labels):\n yield from resolve_label_conflict(mapping, existing, old_labels, new_labels)\n else:\n yield mapping\n\n\ndef child_structure_dfs(sampler, seen=None):\n \"\"\"Return the structure of a composed sampler using a depth-first search on its\n children.\n\n Args:\n sampler (:obj:`.Sampler`):\n :class:`.Structured` or composed sampler with at least\n one structured child.\n\n seen (set, optional, default=False):\n IDs of already checked child samplers.\n\n Returns:\n :class:`~collections.namedtuple`: A named tuple of the form\n `Structure(nodelist, edgelist, adjacency)`, where the 3-tuple values\n are the :attr:`.Structured.nodelist`, :attr:`.Structured.edgelist`\n and :attr:`.Structured.adjacency` attributes of the first structured\n sampler found.\n\n Raises:\n ValueError: If no structured sampler is found.\n\n Examples:\n\n >>> sampler = dimod.TrackingComposite(\n ... dimod.StructureComposite(\n ... dimod.ExactSolver(), [0, 1], [(0, 1)]))\n >>> print(dimod.child_structure_dfs(sampler).nodelist)\n [0, 1]\n\n\n \"\"\"\n seen = set() if seen is None else seen\n\n if sampler not in seen:\n try:\n return sampler.structure\n except AttributeError:\n # hasattr just tries to access anyway...\n pass\n\n seen.add(sampler)\n\n for child in getattr(sampler, 'children', ()): # getattr handles samplers\n if child in seen:\n continue\n\n try:\n return child_structure_dfs(child, seen=seen)\n except ValueError:\n # tree has no child samplers\n pass\n\n raise ValueError(\"no structured sampler found\")\n\n\ndef get_include():\n \"\"\"Return the directory with dimod's header files.\"\"\"\n return os.path.join(os.path.dirname(__file__), 'include')\n\n\ndef _astypearrays(arrays, requirements, min_itemsize, allowed_types):\n # allowed types can only be numeric for now, see comment below\n # todo: allow unsafe with warning controlled by kwarg?\n\n # We need to get the dtype, and as far as I can tell the only way to do\n # it for array-like is to actually cast to a numpy array\n arrays = [np.asarray(arr) for arr in arrays]\n\n # get the dtype we can promote to\n dtype = reduce(np.promote_types, (arr.dtype for arr in arrays))\n\n if not any(np.issubdtype(dtype, type_) for type_ in allowed_types):\n # put together an appropriate error message\n descriptors = []\n if np.floating in allowed_types:\n descriptors.append('floating')\n if np.integer in allowed_types:\n descriptors.append('integer')\n elif np.unsignedinteger in allowed_types:\n if np.signedinteger in allowed_types:\n descriptors.append('integer')\n else:\n descriptors.append('unsigned integer')\n elif np.signedinteger in allowed_types:\n descriptors.append('signed integer')\n\n raise TypeError(\n \"Cannot safely cast arrays to {} (given {})\".format(\n ', '.join(descriptors),\n ', '.join(arr.dtype.name for arr in arrays)))\n\n if min_itemsize is not None:\n if min_itemsize >= 1:\n size = str(2**int(np.ceil(np.log2(min_itemsize))))\n else:\n size = '1'\n if np.issubdtype(dtype, np.unsignedinteger):\n kind = 'u'\n elif np.issubdtype(dtype, np.signedinteger):\n kind = 'i'\n elif np.issubdtype(dtype, np.floating):\n kind = 'f'\n else:\n # we could instead read this from the type string, but it's kind of\n # pandora's box, because there's also structured arrays, complex,\n # etc. For now, let's just restrict to numeric.\n raise RuntimeError(\"unexpected dtype\")\n dtype = np.promote_types(dtype, kind+size)\n\n arrays = tuple(np.require(arr, dtype=dtype, requirements=requirements)\n for arr in arrays)\n\n if len(arrays) > 1:\n return arrays\n else:\n return arrays[0]\n\n\n# Not a public function (yet)\ndef asintegerarrays(*arrays, requirements=None, min_itemsize=None):\n \"\"\"Cast the given array(s) to the same integer type.\n\n Not a public function.\n\n This is useful when calling cython functions.\n\n Args:\n *arrays (array-like): At least one array-like.\n\n requirements (str/list[str], optional): See :func:`numpy.require`.\n\n min_itemsize (int, optional):\n The minimum itemsize (in bytes) for the output arrays.\n\n Returns:\n Numpy array(s) satisfying the above requirements. They will all have\n the same dtype.\n\n \"\"\"\n # empty arrays are a problem because numy defaults them to float, so let's\n # do a tiny bit of prechecking\n arrays = [arr if len(arr) else np.asarray(arr, dtype=np.int8)\n for arr in arrays]\n\n if not arrays:\n raise TypeError('asintegerarrays() takes at least 1 array (0 given)')\n\n return _astypearrays(arrays, requirements, min_itemsize, [np.integer])\n\n\n# Not a public function (yet)\ndef asnumericarrays(*arrays, requirements=None, min_itemsize=None):\n \"\"\"Cast the given array(s) to the same floating type.\n\n Not a public function.\n\n This is useful when calling cython functions.\n\n Args:\n *arrays (array-like): At least one array-like.\n\n requirements (str/list[str], optional): See :func:`numpy.require`.\n\n min_itemsize (int, optional):\n The minimum itemsize (in bytes) for the output arrays.\n\n Returns:\n Numpy array(s) satisfying the above requirements. They will all have\n the same dtype.\n\n \"\"\"\n if not arrays:\n raise TypeError('asnumericarrays() takes at least 1 array (0 given)')\n\n return _astypearrays(arrays, requirements, min_itemsize,\n [np.integer, np.floating])\n" ]

[ [ "numpy.log2", "numpy.asarray", "numpy.issubdtype", "numpy.promote_types", "numpy.require" ] ]

braedynl/DasCrazy

[ "02a3e41631929eaf402116d25299ec252f6fee2f" ]

[ "clean.py" ]

[ "import pandas as pd\n\nfrom util import load\n\n\ndef main(raw_filename: str, clean_filename: str) -> None:\n raw_data = load(raw_filename)\n clean_data = pd.DataFrame(columns=raw_data.columns)\n\n # First chat message to signal a \"das crazy\" moment\n indicator_row = None\n\n for _, row in raw_data.iterrows():\n\n message = row[\"message\"].lower()\n\n if \"crazy\" in message:\n\n # Filters other users messaging at (roughly) the same time, i.e., discards\n # all messages containing the word \"crazy\" within a 30 second interval\n\n # The user can alternatively be myself, as I will notate \"x2\" if there were\n # two back-to-back crazy moments (I've never witnessed more than two)\n if (\n (indicator_row is None)\n or (row[\"user\"] == \"braedynl_\" and \"x2\" in message)\n or (row[\"sent\"] - indicator_row[\"sent\"]).total_seconds() > 30\n ):\n indicator_row = row\n clean_data = clean_data.append(row, ignore_index=True)\n\n clean_data.to_csv(f\"data/{clean_filename}.csv\", index=False)\n\n\nif __name__ == \"__main__\":\n main(\"raw\", \"clean\")\n" ]

[ [ "pandas.DataFrame" ] ]

reic/groupLearning-Python-100-Days

[ "91746e6ee3acf2dbf0e9d324f6c6ce3cb91ed131" ]

[ "RE/grb2fig.py" ]

[ "import pandas as pd\nimport os\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport concurrent.futures\n\n\ndef grb_aggr(files, grb_xlsFileName):\n dft = []\n for file in files:\n dft.append(pd.read_excel(file))\n df = pd.concat(dft, ignore_index=True)\n # 輸出合併檔\n df.to_excel(grb_xlsFileName, index=False)\n return df\n\n\ndef year_fig(df, category, grb_figdata, figout=0):\n dft = pd.DataFrame(pd.pivot_table(df, index=category, values=[\n '本期經費(千元)'], aggfunc={'本期經費(千元)': [\"sum\", \"count\"]}).to_records())\n dft.rename(columns={\"('本期經費(千元)', 'count')\": \"件數\",\n \"('本期經費(千元)', 'sum')\": \"經費(千元)\"}, inplace=True)\n if isinstance(category, list):\n index_name = category[0]\n df2 = dft.pivot_table(index=index_name, columns=\"計畫年度\", values=[\n \"件數\", \"經費(千元)\"], fill_value=0)\n # df2.columns.name = None\n df2 = df2.reset_index()\n df2.to_excel(\n \"{}/{}_件數_經費.xlsx\".format(grb_figdata, category))\n df2.to_excel(\n \"{}/{}_件數_經費.xlsx\".format(grb_figdata, category))\n return\n dft.to_excel(\"{}/{}_件數_經費.xlsx\".format(grb_figdata, category), index=False)\n if figout:\n year_fig2(dft[category], dft[\"件數\"], category, \"件數\")\n year_fig2(dft[category], dft[\"經費(千元)\"], category, \"經費(千元)\")\n\n\ndef data_count(df, category):\n dft = pd.DataFrame(pd.pivot_table(df, index=category, values=[\n '本期經費(千元)'], aggfunc={'本期經費(千元)': [\"sum\", \"count\"]}).to_records())\n dft.rename(columns={\"('本期經費(千元)', 'count')\": \"件數\",\n \"('本期經費(千元)', 'sum')\": \"經費(千元)\"}, inplace=True)\n return dft\n\n\ndef year_fig2(xdata, ydata, xlab, ylab, grb_figdata):\n plt.rcParams['font.sans-serif'] = ['Microsoft JhengHei']\n plt.plot(xdata, ydata)\n plt.xlabel(xlab, fontsize=14)\n plt.ylabel(ylab, fontsize=14)\n plt.savefig(\"{}/{}_{}.png\".format(grb_figdata, xlab, ylab))\n plt.show()\n\n\ndef columnlinechart(writer, sheet_name, maxrow):\n workbook = writer.book\n worksheet = writer.sheets[sheet_name]\n # Create a chart object.\n chart = workbook.add_chart({'type': 'column'})\n\n # Configure the series of the chart from the dataframe data.\n chart.add_series({'name': f\"={sheet_name}!C1\", 'values': f\"={sheet_name}!$C$2:$C${maxrow}\",\n \"categories\": f\"={sheet_name}!$A$2:$A${maxrow}\",\n 'fill': {'color': '#808080'}, 'data_labels': {'value': True}, 'gap': 15})\n\n # 'type': 'column' 即為圖表類別為 line chart\n line_chart = workbook.add_chart({'type': 'line'})\n line_chart.add_series({'name': f\"={sheet_name}!B1\", \"categories\": f\"={sheet_name}!$A$2:$A${maxrow}\", 'values': f\"={sheet_name}!$B$2:$B${maxrow}\", 'data_labels': {'value': True, \"position\": \"above\"},\n 'y2_axis': True, \"marker\": {\"type\": \"circle\", \"size\": \"9\", \"fill\": {\"color\": \"white\"}}}) # 'y2_axis': 表示是否增加 secondary y-axis\n chart.combine(line_chart) # 將兩張圖 (bar chart & line chart) 組合在一起\n\n chart.set_legend({'position': 'top'}) # legend 位置於圖表下方\n chart.set_x_axis({'major_gridlines': {'visible': False}})\n chart.set_y_axis({'major_gridlines': {'visible': False}})\n # Turn off chart legend. It is on by default in Excel.\n # chart.set_legend({'position': 'none'})\n chart.set_size({'width': 800, 'height': 500})\n # Insert the chart into the worksheet.\n worksheet.insert_chart('F2', chart)\n\n\ndef barchart(writer, sheet_name, maxrow, maxcolumn):\n workbook = writer.book\n worksheet = writer.sheets[sheet_name]\n # Create a chart object.\n chart = workbook.add_chart({'type': 'bar', 'subtype': 'percent_stacked'})\n for itm in range(1, maxcolumn):\n colname = chr(65+itm)\n chart.add_series({\"name\": f\"='{sheet_name}'!${colname}$1\",\n 'categories': f\"='{sheet_name}'!$A$2:$A${maxrow}\",\n \"values\": f\"='{sheet_name}'!${colname}$2:${colname}${maxrow}\"\n })\n chart.set_legend({'position': 'top'}) # legend 位置於圖表下方\n chart.set_style(13)\n chart.set_y_axis({'major_gridlines': {'visible': False}})\n chart.set_x_axis({'major_gridlines': {'visible': False}})\n chart.set_size({'width': 800, 'height': 500})\n worksheet.insert_chart(\"F2\", chart)\n\n\ndef piechart(writer, sheet_name, maxrow):\n workbook = writer.book\n worksheet = writer.sheets[sheet_name]\n chart = workbook.add_chart({\"type\": \"pie\"})\n chart.add_series({'categories': f\"='{sheet_name}'!$A$2:$A${maxrow}\",\n \"values\": f\"='{sheet_name}'!$C$2:$C${maxrow}\",\n 'data_labels': {'category': True, 'percentage': True},\n })\n chart.set_legend({'position': 'left'}) # legend 位置於圖表下方\n chart.set_style(13)\n chart.set_size({'width': 800, 'height': 500})\n worksheet.insert_chart(\"F2\", chart)\n\n\ndef yeardiv(dfyears, period):\n # dfyears 為 df[\"year\"].values 的值\n years = list(set(dfyears))\n start = min(years)\n grouplabel = [f\"{itm}~{itm+period-1}\" for itm in years[::period]]\n groupyear = []\n for itm in dfyears:\n groupyear.append(grouplabel[(itm-start)//period])\n return groupyear\n\n\ndef checkdict(context, wordDict):\n if context in wordDict:\n wordDict[context] += 1\n else:\n wordDict[context] = 1\n\n\ndef main(grb_dir):\n print(grb_dir)\n grb_xlsFileName = f\"{grb_dir[:6]}_grb.xlsx\"\n outputfilename = f\"{grb_dir[:6]}_output.xlsx\"\n # 取得下載 xlsx 所有檔案名稱\n files = [\"{}/{}\".format(grb_dir, i) for i in os.listdir(grb_dir)]\n\n # 執行 xslx 合併檔案\n df = grb_aggr(files, grb_xlsFileName)\n # df = pd.read_excel(\"D:/grb.xlsx\")\n\n # 資料處理的工作\n # 僅取出國科會、科技部的計畫\n filterlist = [\"行政院國家科學委員會\", \"科技部\"]\n df1 = df[df[\"計畫主管機關\"].isin(filterlist)][['計畫中文名稱', '執行單位名稱', '計畫年度', '計畫主管機關', '研究性質', '研究領域', '本期期間(起)', '本期期間(訖)', '本期經費(千元)',\n '計畫主持人', '共同/協同主持人', '中文關鍵詞', '英文關鍵詞']]\n # 研究領域，僅取出第一個研究領域分析\n df1[\"主研究領域\"] = [itm[0] for itm in df1[\"研究領域\"].str.split(\";\").values]\n # 執行機構名稱的清理\n df1[\"執行單位_new\"] = [str(itm[1]).replace(\"台灣\", \"臺灣\") for itm in df1[\"執行單位名稱\"].str.extract(\n r'(國立|.*法人|行政院)?(.*大學|.*學院|.*研究院|.*學會|.*學校|原子能委員會|食品工業發展研究所|國家同步輻射研究中心|林業試驗所|中醫藥研究所)').values]\n # 輸出整理過的檔案\n df1.to_excel(\"{}_整理.xlsx\".format(\n grb_xlsFileName[:grb_xlsFileName.rfind(\".\")]), index=False)\n\n with pd.ExcelWriter(outputfilename, engine='xlsxwriter') as writer:\n tmp = data_count(df1, \"計畫年度\")\n maxrow = len(tmp)+1\n tmp.to_excel(writer, sheet_name=\"計畫年度\", index=False)\n columnlinechart(writer, \"計畫年度\", maxrow)\n\n tmp = data_count(df, [\"研究性質\", \"計畫年度\"])\n mask = tmp[\"研究性質\"] == \"其他\"\n tmp[~mask].to_excel(writer, sheet_name=\"研究性質with年度\", index=False)\n\n tmp = data_count(df1, [\"研究性質\", \"計畫年度\"])\n mask = tmp[\"研究性質\"] == \"其他\"\n tmp = tmp[~mask]\n tmp.to_excel(writer, sheet_name=\"MOST 研究性質with年度\", index=False)\n for j in [4, 3, 2]:\n yearlen = len(set(tmp[\"計畫年度\"].values))\n if yearlen % j == 0:\n divdat = yearlen//j\n break\n\n groupyear = yeardiv(tmp[\"計畫年度\"].values, divdat)\n tmp[\"計畫年度\"] = groupyear\n tmp = pd.DataFrame(pd.pivot_table(tmp, index=\"研究性質\",\n values=\"經費(千元)\", columns=[\"計畫年度\"]).to_records())\n sindex = tmp.index.to_list()\n sindex[0] = 4\n tmp.index = sindex\n tmp.sort_index(inplace=True)\n tmp.to_excel(writer, sheet_name=\"MOST 研究性質 with 年度區間\", index=False)\n maxrow = len(tmp)+1\n maxcolumn = len(tmp.columns)\n barchart(writer, \"MOST 研究性質 with 年度區間\", maxrow, maxcolumn)\n\n tmp = data_count(df1, \"主研究領域\")\n tmp.sort_values(\"經費(千元)\", ascending=False, inplace=True)\n maxrow = len(tmp)+1\n tmp.to_excel(writer, \"主研究領域\", index=False)\n if maxrow > 13:\n maxrow = 13\n piechart(writer, \"主研究領域\", maxrow)\n\n sheetname = \"執行單位_new\"\n tmp = data_count(df1, sheetname)\n tmp.sort_values(\"經費(千元)\", ascending=False, inplace=True)\n maxrow = len(tmp)+1\n tmp.to_excel(writer, sheet_name=sheetname, index=False)\n if maxrow > 25:\n maxrow = 25\n piechart(writer, sheetname, maxrow)\n\n\nif __name__ == \"__main__\":\n # 定義區\n # 設定工作目錄\n working_dir = \"d:/tmp\"\n txt_data = \"txt\"\n os.chdir(working_dir)\n grb_dirs = [\"solarcell\", \"hydrogen\",\n \"storeenergy\", 'sysintegrate', 'windturbine']\n\n # # 做圖用的 xlsx 分檔的輸出位置\n grb_figdata = \"data2fig\"\n\n # # 建立 xlsx 輸出檔的存放目錄\n try:\n os.mkdir(txt_data)\n except FileExistsError:\n print(\"%s 的目標已存在\" % txt_data)\n\n try:\n os.mkdir(grb_figdata)\n except FileExistsError:\n print(\"%s 的目標已存在\" % grb_figdata)\n\n with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:\n executor.map(main, grb_dirs)\n" ]

[ [ "pandas.concat", "pandas.read_excel", "matplotlib.pyplot.plot", "pandas.ExcelWriter", "matplotlib.pyplot.xlabel", "pandas.pivot_table", "matplotlib.pyplot.show", "matplotlib.pyplot.ylabel" ] ]

HumHongeKamyaab/scipy

[ "ce61e02e912d15ea28b37ea036334b9ba266ebb5" ]

[ "scipy/special/tests/test_data.py" ]

[ "import os\n\nimport numpy as np\nfrom numpy import arccosh, arcsinh, arctanh\nfrom numpy.testing import suppress_warnings\nimport pytest\n\nfrom scipy.special import (\n lpn, lpmn, lpmv, lqn, lqmn, sph_harm, eval_legendre, eval_hermite,\n eval_laguerre, eval_genlaguerre, binom, cbrt, expm1, log1p, zeta,\n jn, jv, jvp, yn, yv, yvp, iv, ivp, kn, kv, kvp,\n gamma, gammaln, gammainc, gammaincc, gammaincinv, gammainccinv, digamma,\n beta, betainc, betaincinv, poch,\n ellipe, ellipeinc, ellipk, ellipkm1, ellipkinc, ellipj,\n elliprc, elliprd, elliprf, elliprg, elliprj,\n erf, erfc, erfinv, erfcinv, exp1, expi, expn,\n bdtrik, btdtr, btdtri, btdtria, btdtrib, chndtr, gdtr, gdtrc, gdtrix, gdtrib,\n nbdtrik, pdtrik, owens_t,\n mathieu_a, mathieu_b, mathieu_cem, mathieu_sem, mathieu_modcem1,\n mathieu_modsem1, mathieu_modcem2, mathieu_modsem2,\n ellip_harm, ellip_harm_2, spherical_jn, spherical_yn,\n)\nfrom scipy.integrate import IntegrationWarning\n\nfrom scipy.special._testutils import FuncData\n\nDATASETS_BOOST = np.load(os.path.join(os.path.dirname(__file__),\n \"data\", \"boost.npz\"))\n\nDATASETS_GSL = np.load(os.path.join(os.path.dirname(__file__),\n \"data\", \"gsl.npz\"))\n\nDATASETS_LOCAL = np.load(os.path.join(os.path.dirname(__file__),\n \"data\", \"local.npz\"))\n\n\ndef data(func, dataname, *a, **kw):\n kw.setdefault('dataname', dataname)\n return FuncData(func, DATASETS_BOOST[dataname], *a, **kw)\n\n\ndef data_gsl(func, dataname, *a, **kw):\n kw.setdefault('dataname', dataname)\n return FuncData(func, DATASETS_GSL[dataname], *a, **kw)\n\n\ndef data_local(func, dataname, *a, **kw):\n kw.setdefault('dataname', dataname)\n return FuncData(func, DATASETS_LOCAL[dataname], *a, **kw)\n\n\ndef ellipk_(k):\n return ellipk(k*k)\n\n\ndef ellipkinc_(f, k):\n return ellipkinc(f, k*k)\n\n\ndef ellipe_(k):\n return ellipe(k*k)\n\n\ndef ellipeinc_(f, k):\n return ellipeinc(f, k*k)\n\n\ndef ellipj_(k):\n return ellipj(k*k)\n\n\ndef zeta_(x):\n return zeta(x, 1.)\n\n\ndef assoc_legendre_p_boost_(nu, mu, x):\n # the boost test data is for integer orders only\n return lpmv(mu, nu.astype(int), x)\n\ndef legendre_p_via_assoc_(nu, x):\n return lpmv(0, nu, x)\n\ndef lpn_(n, x):\n return lpn(n.astype('l'), x)[0][-1]\n\ndef lqn_(n, x):\n return lqn(n.astype('l'), x)[0][-1]\n\ndef legendre_p_via_lpmn(n, x):\n return lpmn(0, n, x)[0][0,-1]\n\ndef legendre_q_via_lqmn(n, x):\n return lqmn(0, n, x)[0][0,-1]\n\ndef mathieu_ce_rad(m, q, x):\n return mathieu_cem(m, q, x*180/np.pi)[0]\n\n\ndef mathieu_se_rad(m, q, x):\n return mathieu_sem(m, q, x*180/np.pi)[0]\n\n\ndef mathieu_mc1_scaled(m, q, x):\n # GSL follows a different normalization.\n # We follow Abramowitz & Stegun, they apparently something else.\n return mathieu_modcem1(m, q, x)[0] * np.sqrt(np.pi/2)\n\n\ndef mathieu_ms1_scaled(m, q, x):\n return mathieu_modsem1(m, q, x)[0] * np.sqrt(np.pi/2)\n\n\ndef mathieu_mc2_scaled(m, q, x):\n return mathieu_modcem2(m, q, x)[0] * np.sqrt(np.pi/2)\n\n\ndef mathieu_ms2_scaled(m, q, x):\n return mathieu_modsem2(m, q, x)[0] * np.sqrt(np.pi/2)\n\ndef eval_legendre_ld(n, x):\n return eval_legendre(n.astype('l'), x)\n\ndef eval_legendre_dd(n, x):\n return eval_legendre(n.astype('d'), x)\n\ndef eval_hermite_ld(n, x):\n return eval_hermite(n.astype('l'), x)\n\ndef eval_laguerre_ld(n, x):\n return eval_laguerre(n.astype('l'), x)\n\ndef eval_laguerre_dd(n, x):\n return eval_laguerre(n.astype('d'), x)\n\ndef eval_genlaguerre_ldd(n, a, x):\n return eval_genlaguerre(n.astype('l'), a, x)\n\ndef eval_genlaguerre_ddd(n, a, x):\n return eval_genlaguerre(n.astype('d'), a, x)\n\ndef bdtrik_comp(y, n, p):\n return bdtrik(1-y, n, p)\n\ndef btdtri_comp(a, b, p):\n return btdtri(a, b, 1-p)\n\ndef btdtria_comp(p, b, x):\n return btdtria(1-p, b, x)\n\ndef btdtrib_comp(a, p, x):\n return btdtrib(a, 1-p, x)\n\ndef gdtr_(p, x):\n return gdtr(1.0, p, x)\n\ndef gdtrc_(p, x):\n return gdtrc(1.0, p, x)\n\ndef gdtrix_(b, p):\n return gdtrix(1.0, b, p)\n\ndef gdtrix_comp(b, p):\n return gdtrix(1.0, b, 1-p)\n\ndef gdtrib_(p, x):\n return gdtrib(1.0, p, x)\n\ndef gdtrib_comp(p, x):\n return gdtrib(1.0, 1-p, x)\n\ndef nbdtrik_comp(y, n, p):\n return nbdtrik(1-y, n, p)\n\ndef pdtrik_comp(p, m):\n return pdtrik(1-p, m)\n\ndef poch_(z, m):\n return 1.0 / poch(z, m)\n\ndef poch_minus(z, m):\n return 1.0 / poch(z, -m)\n\ndef spherical_jn_(n, x):\n return spherical_jn(n.astype('l'), x)\n\ndef spherical_yn_(n, x):\n return spherical_yn(n.astype('l'), x)\n\ndef sph_harm_(m, n, theta, phi):\n y = sph_harm(m, n, theta, phi)\n return (y.real, y.imag)\n\ndef cexpm1(x, y):\n z = expm1(x + 1j*y)\n return z.real, z.imag\n\ndef clog1p(x, y):\n z = log1p(x + 1j*y)\n return z.real, z.imag\n\n\nBOOST_TESTS = [\n data(arccosh, 'acosh_data_ipp-acosh_data', 0, 1, rtol=5e-13),\n data(arccosh, 'acosh_data_ipp-acosh_data', 0j, 1, rtol=5e-13),\n\n data(arcsinh, 'asinh_data_ipp-asinh_data', 0, 1, rtol=1e-11),\n data(arcsinh, 'asinh_data_ipp-asinh_data', 0j, 1, rtol=1e-11),\n\n data(arctanh, 'atanh_data_ipp-atanh_data', 0, 1, rtol=1e-11),\n data(arctanh, 'atanh_data_ipp-atanh_data', 0j, 1, rtol=1e-11),\n\n data(assoc_legendre_p_boost_, 'assoc_legendre_p_ipp-assoc_legendre_p', (0,1,2), 3, rtol=1e-11),\n\n data(legendre_p_via_assoc_, 'legendre_p_ipp-legendre_p', (0,1), 2, rtol=1e-11),\n data(legendre_p_via_assoc_, 'legendre_p_large_ipp-legendre_p_large', (0,1), 2, rtol=9.6e-14),\n data(legendre_p_via_lpmn, 'legendre_p_ipp-legendre_p', (0,1), 2, rtol=5e-14, vectorized=False),\n data(legendre_p_via_lpmn, 'legendre_p_large_ipp-legendre_p_large', (0,1), 2, rtol=9.6e-14, vectorized=False),\n data(lpn_, 'legendre_p_ipp-legendre_p', (0,1), 2, rtol=5e-14, vectorized=False),\n data(lpn_, 'legendre_p_large_ipp-legendre_p_large', (0,1), 2, rtol=3e-13, vectorized=False),\n data(eval_legendre_ld, 'legendre_p_ipp-legendre_p', (0,1), 2, rtol=6e-14),\n data(eval_legendre_ld, 'legendre_p_large_ipp-legendre_p_large', (0,1), 2, rtol=2e-13),\n data(eval_legendre_dd, 'legendre_p_ipp-legendre_p', (0,1), 2, rtol=2e-14),\n data(eval_legendre_dd, 'legendre_p_large_ipp-legendre_p_large', (0,1), 2, rtol=2e-13),\n\n data(lqn_, 'legendre_p_ipp-legendre_p', (0,1), 3, rtol=2e-14, vectorized=False),\n data(lqn_, 'legendre_p_large_ipp-legendre_p_large', (0,1), 3, rtol=2e-12, vectorized=False),\n data(legendre_q_via_lqmn, 'legendre_p_ipp-legendre_p', (0,1), 3, rtol=2e-14, vectorized=False),\n data(legendre_q_via_lqmn, 'legendre_p_large_ipp-legendre_p_large', (0,1), 3, rtol=2e-12, vectorized=False),\n\n data(beta, 'beta_exp_data_ipp-beta_exp_data', (0,1), 2, rtol=1e-13),\n data(beta, 'beta_exp_data_ipp-beta_exp_data', (0,1), 2, rtol=1e-13),\n data(beta, 'beta_med_data_ipp-beta_med_data', (0,1), 2, rtol=5e-13),\n\n data(betainc, 'ibeta_small_data_ipp-ibeta_small_data', (0,1,2), 5, rtol=6e-15),\n data(betainc, 'ibeta_data_ipp-ibeta_data', (0,1,2), 5, rtol=5e-13),\n data(betainc, 'ibeta_int_data_ipp-ibeta_int_data', (0,1,2), 5, rtol=2e-14),\n data(betainc, 'ibeta_large_data_ipp-ibeta_large_data', (0,1,2), 5, rtol=4e-10),\n\n data(betaincinv, 'ibeta_inv_data_ipp-ibeta_inv_data', (0,1,2), 3, rtol=1e-5),\n\n data(btdtr, 'ibeta_small_data_ipp-ibeta_small_data', (0,1,2), 5, rtol=6e-15),\n data(btdtr, 'ibeta_data_ipp-ibeta_data', (0,1,2), 5, rtol=4e-13),\n data(btdtr, 'ibeta_int_data_ipp-ibeta_int_data', (0,1,2), 5, rtol=2e-14),\n data(btdtr, 'ibeta_large_data_ipp-ibeta_large_data', (0,1,2), 5, rtol=4e-10),\n\n data(btdtri, 'ibeta_inv_data_ipp-ibeta_inv_data', (0,1,2), 3, rtol=1e-5),\n data(btdtri_comp, 'ibeta_inv_data_ipp-ibeta_inv_data', (0,1,2), 4, rtol=8e-7),\n\n data(btdtria, 'ibeta_inva_data_ipp-ibeta_inva_data', (2,0,1), 3, rtol=5e-9),\n data(btdtria_comp, 'ibeta_inva_data_ipp-ibeta_inva_data', (2,0,1), 4, rtol=5e-9),\n\n data(btdtrib, 'ibeta_inva_data_ipp-ibeta_inva_data', (0,2,1), 5, rtol=5e-9),\n data(btdtrib_comp, 'ibeta_inva_data_ipp-ibeta_inva_data', (0,2,1), 6, rtol=5e-9),\n\n data(binom, 'binomial_data_ipp-binomial_data', (0,1), 2, rtol=1e-13),\n data(binom, 'binomial_large_data_ipp-binomial_large_data', (0,1), 2, rtol=5e-13),\n\n data(bdtrik, 'binomial_quantile_ipp-binomial_quantile_data', (2,0,1), 3, rtol=5e-9),\n data(bdtrik_comp, 'binomial_quantile_ipp-binomial_quantile_data', (2,0,1), 4, rtol=5e-9),\n\n data(nbdtrik, 'negative_binomial_quantile_ipp-negative_binomial_quantile_data', (2,0,1), 3, rtol=4e-9),\n data(nbdtrik_comp, 'negative_binomial_quantile_ipp-negative_binomial_quantile_data', (2,0,1), 4, rtol=4e-9),\n\n data(pdtrik, 'poisson_quantile_ipp-poisson_quantile_data', (1,0), 2, rtol=3e-9),\n data(pdtrik_comp, 'poisson_quantile_ipp-poisson_quantile_data', (1,0), 3, rtol=4e-9),\n\n data(cbrt, 'cbrt_data_ipp-cbrt_data', 1, 0),\n\n data(digamma, 'digamma_data_ipp-digamma_data', 0, 1),\n data(digamma, 'digamma_data_ipp-digamma_data', 0j, 1),\n data(digamma, 'digamma_neg_data_ipp-digamma_neg_data', 0, 1, rtol=2e-13),\n data(digamma, 'digamma_neg_data_ipp-digamma_neg_data', 0j, 1, rtol=1e-13),\n data(digamma, 'digamma_root_data_ipp-digamma_root_data', 0, 1, rtol=1e-15),\n data(digamma, 'digamma_root_data_ipp-digamma_root_data', 0j, 1, rtol=1e-15),\n data(digamma, 'digamma_small_data_ipp-digamma_small_data', 0, 1, rtol=1e-15),\n data(digamma, 'digamma_small_data_ipp-digamma_small_data', 0j, 1, rtol=1e-14),\n\n data(ellipk_, 'ellint_k_data_ipp-ellint_k_data', 0, 1),\n data(ellipkinc_, 'ellint_f_data_ipp-ellint_f_data', (0,1), 2, rtol=1e-14),\n data(ellipe_, 'ellint_e_data_ipp-ellint_e_data', 0, 1),\n data(ellipeinc_, 'ellint_e2_data_ipp-ellint_e2_data', (0,1), 2, rtol=1e-14),\n\n data(erf, 'erf_data_ipp-erf_data', 0, 1),\n data(erf, 'erf_data_ipp-erf_data', 0j, 1, rtol=1e-13),\n data(erfc, 'erf_data_ipp-erf_data', 0, 2, rtol=6e-15),\n data(erf, 'erf_large_data_ipp-erf_large_data', 0, 1),\n data(erf, 'erf_large_data_ipp-erf_large_data', 0j, 1),\n data(erfc, 'erf_large_data_ipp-erf_large_data', 0, 2, rtol=4e-14),\n data(erf, 'erf_small_data_ipp-erf_small_data', 0, 1),\n data(erf, 'erf_small_data_ipp-erf_small_data', 0j, 1, rtol=1e-13),\n data(erfc, 'erf_small_data_ipp-erf_small_data', 0, 2),\n\n data(erfinv, 'erf_inv_data_ipp-erf_inv_data', 0, 1),\n data(erfcinv, 'erfc_inv_data_ipp-erfc_inv_data', 0, 1),\n data(erfcinv, 'erfc_inv_big_data_ipp-erfc_inv_big_data', 0, 1, param_filter=(lambda s: s > 0)),\n\n data(exp1, 'expint_1_data_ipp-expint_1_data', 1, 2, rtol=1e-13),\n data(exp1, 'expint_1_data_ipp-expint_1_data', 1j, 2, rtol=5e-9),\n data(expi, 'expinti_data_ipp-expinti_data', 0, 1, rtol=1e-13),\n data(expi, 'expinti_data_double_ipp-expinti_data_double', 0, 1, rtol=1e-13),\n data(expi, 'expinti_data_long_ipp-expinti_data_long', 0, 1),\n\n data(expn, 'expint_small_data_ipp-expint_small_data', (0,1), 2),\n data(expn, 'expint_data_ipp-expint_data', (0,1), 2, rtol=1e-14),\n\n data(gamma, 'test_gamma_data_ipp-near_0', 0, 1),\n data(gamma, 'test_gamma_data_ipp-near_1', 0, 1),\n data(gamma, 'test_gamma_data_ipp-near_2', 0, 1),\n data(gamma, 'test_gamma_data_ipp-near_m10', 0, 1),\n data(gamma, 'test_gamma_data_ipp-near_m55', 0, 1, rtol=7e-12),\n data(gamma, 'test_gamma_data_ipp-factorials', 0, 1, rtol=4e-14),\n data(gamma, 'test_gamma_data_ipp-near_0', 0j, 1, rtol=2e-9),\n data(gamma, 'test_gamma_data_ipp-near_1', 0j, 1, rtol=2e-9),\n data(gamma, 'test_gamma_data_ipp-near_2', 0j, 1, rtol=2e-9),\n data(gamma, 'test_gamma_data_ipp-near_m10', 0j, 1, rtol=2e-9),\n data(gamma, 'test_gamma_data_ipp-near_m55', 0j, 1, rtol=2e-9),\n data(gamma, 'test_gamma_data_ipp-factorials', 0j, 1, rtol=2e-13),\n data(gammaln, 'test_gamma_data_ipp-near_0', 0, 2, rtol=5e-11),\n data(gammaln, 'test_gamma_data_ipp-near_1', 0, 2, rtol=5e-11),\n data(gammaln, 'test_gamma_data_ipp-near_2', 0, 2, rtol=2e-10),\n data(gammaln, 'test_gamma_data_ipp-near_m10', 0, 2, rtol=5e-11),\n data(gammaln, 'test_gamma_data_ipp-near_m55', 0, 2, rtol=5e-11),\n data(gammaln, 'test_gamma_data_ipp-factorials', 0, 2),\n\n data(gammainc, 'igamma_small_data_ipp-igamma_small_data', (0,1), 5, rtol=5e-15),\n data(gammainc, 'igamma_med_data_ipp-igamma_med_data', (0,1), 5, rtol=2e-13),\n data(gammainc, 'igamma_int_data_ipp-igamma_int_data', (0,1), 5, rtol=2e-13),\n data(gammainc, 'igamma_big_data_ipp-igamma_big_data', (0,1), 5, rtol=1e-12),\n\n data(gdtr_, 'igamma_small_data_ipp-igamma_small_data', (0,1), 5, rtol=1e-13),\n data(gdtr_, 'igamma_med_data_ipp-igamma_med_data', (0,1), 5, rtol=2e-13),\n data(gdtr_, 'igamma_int_data_ipp-igamma_int_data', (0,1), 5, rtol=2e-13),\n data(gdtr_, 'igamma_big_data_ipp-igamma_big_data', (0,1), 5, rtol=2e-9),\n\n data(gammaincc, 'igamma_small_data_ipp-igamma_small_data', (0,1), 3, rtol=1e-13),\n data(gammaincc, 'igamma_med_data_ipp-igamma_med_data', (0,1), 3, rtol=2e-13),\n data(gammaincc, 'igamma_int_data_ipp-igamma_int_data', (0,1), 3, rtol=4e-14),\n data(gammaincc, 'igamma_big_data_ipp-igamma_big_data', (0,1), 3, rtol=1e-11),\n\n data(gdtrc_, 'igamma_small_data_ipp-igamma_small_data', (0,1), 3, rtol=1e-13),\n data(gdtrc_, 'igamma_med_data_ipp-igamma_med_data', (0,1), 3, rtol=2e-13),\n data(gdtrc_, 'igamma_int_data_ipp-igamma_int_data', (0,1), 3, rtol=4e-14),\n data(gdtrc_, 'igamma_big_data_ipp-igamma_big_data', (0,1), 3, rtol=1e-11),\n\n data(gdtrib_, 'igamma_inva_data_ipp-igamma_inva_data', (1,0), 2, rtol=5e-9),\n data(gdtrib_comp, 'igamma_inva_data_ipp-igamma_inva_data', (1,0), 3, rtol=5e-9),\n\n data(poch_, 'tgamma_delta_ratio_data_ipp-tgamma_delta_ratio_data', (0,1), 2, rtol=2e-13),\n data(poch_, 'tgamma_delta_ratio_int_ipp-tgamma_delta_ratio_int', (0,1), 2,),\n data(poch_, 'tgamma_delta_ratio_int2_ipp-tgamma_delta_ratio_int2', (0,1), 2,),\n data(poch_minus, 'tgamma_delta_ratio_data_ipp-tgamma_delta_ratio_data', (0,1), 3, rtol=2e-13),\n data(poch_minus, 'tgamma_delta_ratio_int_ipp-tgamma_delta_ratio_int', (0,1), 3),\n data(poch_minus, 'tgamma_delta_ratio_int2_ipp-tgamma_delta_ratio_int2', (0,1), 3),\n\n data(eval_hermite_ld, 'hermite_ipp-hermite', (0,1), 2, rtol=2e-14),\n\n data(eval_laguerre_ld, 'laguerre2_ipp-laguerre2', (0,1), 2, rtol=7e-12),\n data(eval_laguerre_dd, 'laguerre2_ipp-laguerre2', (0,1), 2, knownfailure='hyp2f1 insufficiently accurate.'),\n data(eval_genlaguerre_ldd, 'laguerre3_ipp-laguerre3', (0,1,2), 3, rtol=2e-13),\n data(eval_genlaguerre_ddd, 'laguerre3_ipp-laguerre3', (0,1,2), 3, knownfailure='hyp2f1 insufficiently accurate.'),\n\n data(log1p, 'log1p_expm1_data_ipp-log1p_expm1_data', 0, 1),\n data(expm1, 'log1p_expm1_data_ipp-log1p_expm1_data', 0, 2),\n\n data(iv, 'bessel_i_data_ipp-bessel_i_data', (0,1), 2, rtol=1e-12),\n data(iv, 'bessel_i_data_ipp-bessel_i_data', (0,1j), 2, rtol=2e-10, atol=1e-306),\n data(iv, 'bessel_i_int_data_ipp-bessel_i_int_data', (0,1), 2, rtol=1e-9),\n data(iv, 'bessel_i_int_data_ipp-bessel_i_int_data', (0,1j), 2, rtol=2e-10),\n\n data(ivp, 'bessel_i_prime_int_data_ipp-bessel_i_prime_int_data', (0,1), 2, rtol=1.2e-13),\n data(ivp, 'bessel_i_prime_int_data_ipp-bessel_i_prime_int_data', (0,1j), 2, rtol=1.2e-13, atol=1e-300),\n\n data(jn, 'bessel_j_int_data_ipp-bessel_j_int_data', (0,1), 2, rtol=1e-12),\n data(jn, 'bessel_j_int_data_ipp-bessel_j_int_data', (0,1j), 2, rtol=1e-12),\n data(jn, 'bessel_j_large_data_ipp-bessel_j_large_data', (0,1), 2, rtol=6e-11),\n data(jn, 'bessel_j_large_data_ipp-bessel_j_large_data', (0,1j), 2, rtol=6e-11),\n\n data(jv, 'bessel_j_int_data_ipp-bessel_j_int_data', (0,1), 2, rtol=1e-12),\n data(jv, 'bessel_j_int_data_ipp-bessel_j_int_data', (0,1j), 2, rtol=1e-12),\n data(jv, 'bessel_j_data_ipp-bessel_j_data', (0,1), 2, rtol=1e-12),\n data(jv, 'bessel_j_data_ipp-bessel_j_data', (0,1j), 2, rtol=1e-12),\n\n data(jvp, 'bessel_j_prime_int_data_ipp-bessel_j_prime_int_data', (0,1), 2, rtol=1e-13),\n data(jvp, 'bessel_j_prime_int_data_ipp-bessel_j_prime_int_data', (0,1j), 2, rtol=1e-13),\n data(jvp, 'bessel_j_prime_large_data_ipp-bessel_j_prime_large_data', (0,1), 2, rtol=1e-11),\n data(jvp, 'bessel_j_prime_large_data_ipp-bessel_j_prime_large_data', (0,1j), 2, rtol=1e-11),\n\n data(kn, 'bessel_k_int_data_ipp-bessel_k_int_data', (0,1), 2, rtol=1e-12),\n\n data(kv, 'bessel_k_int_data_ipp-bessel_k_int_data', (0,1), 2, rtol=1e-12),\n data(kv, 'bessel_k_int_data_ipp-bessel_k_int_data', (0,1j), 2, rtol=1e-12),\n data(kv, 'bessel_k_data_ipp-bessel_k_data', (0,1), 2, rtol=1e-12),\n data(kv, 'bessel_k_data_ipp-bessel_k_data', (0,1j), 2, rtol=1e-12),\n\n data(kvp, 'bessel_k_prime_int_data_ipp-bessel_k_prime_int_data', (0,1), 2, rtol=3e-14),\n data(kvp, 'bessel_k_prime_int_data_ipp-bessel_k_prime_int_data', (0,1j), 2, rtol=3e-14),\n data(kvp, 'bessel_k_prime_data_ipp-bessel_k_prime_data', (0,1), 2, rtol=7e-14),\n data(kvp, 'bessel_k_prime_data_ipp-bessel_k_prime_data', (0,1j), 2, rtol=7e-14),\n\n data(yn, 'bessel_y01_data_ipp-bessel_y01_data', (0,1), 2, rtol=1e-12),\n data(yn, 'bessel_yn_data_ipp-bessel_yn_data', (0,1), 2, rtol=1e-12),\n\n data(yv, 'bessel_yn_data_ipp-bessel_yn_data', (0,1), 2, rtol=1e-12),\n data(yv, 'bessel_yn_data_ipp-bessel_yn_data', (0,1j), 2, rtol=1e-12),\n data(yv, 'bessel_yv_data_ipp-bessel_yv_data', (0,1), 2, rtol=1e-10),\n data(yv, 'bessel_yv_data_ipp-bessel_yv_data', (0,1j), 2, rtol=1e-10),\n\n data(yvp, 'bessel_yv_prime_data_ipp-bessel_yv_prime_data', (0, 1), 2, rtol=4e-9),\n data(yvp, 'bessel_yv_prime_data_ipp-bessel_yv_prime_data', (0, 1j), 2, rtol=4e-9),\n\n data(zeta_, 'zeta_data_ipp-zeta_data', 0, 1, param_filter=(lambda s: s > 1)),\n data(zeta_, 'zeta_neg_data_ipp-zeta_neg_data', 0, 1, param_filter=(lambda s: s > 1)),\n data(zeta_, 'zeta_1_up_data_ipp-zeta_1_up_data', 0, 1, param_filter=(lambda s: s > 1)),\n data(zeta_, 'zeta_1_below_data_ipp-zeta_1_below_data', 0, 1, param_filter=(lambda s: s > 1)),\n\n data(gammaincinv, 'gamma_inv_small_data_ipp-gamma_inv_small_data', (0,1), 2, rtol=1e-11),\n data(gammaincinv, 'gamma_inv_data_ipp-gamma_inv_data', (0,1), 2, rtol=1e-14),\n data(gammaincinv, 'gamma_inv_big_data_ipp-gamma_inv_big_data', (0,1), 2, rtol=1e-11),\n\n data(gammainccinv, 'gamma_inv_small_data_ipp-gamma_inv_small_data', (0,1), 3, rtol=1e-12),\n data(gammainccinv, 'gamma_inv_data_ipp-gamma_inv_data', (0,1), 3, rtol=1e-14),\n data(gammainccinv, 'gamma_inv_big_data_ipp-gamma_inv_big_data', (0,1), 3, rtol=1e-14),\n\n data(gdtrix_, 'gamma_inv_small_data_ipp-gamma_inv_small_data', (0,1), 2, rtol=3e-13, knownfailure='gdtrix unflow some points'),\n data(gdtrix_, 'gamma_inv_data_ipp-gamma_inv_data', (0,1), 2, rtol=3e-15),\n data(gdtrix_, 'gamma_inv_big_data_ipp-gamma_inv_big_data', (0,1), 2),\n data(gdtrix_comp, 'gamma_inv_small_data_ipp-gamma_inv_small_data', (0,1), 2, knownfailure='gdtrix bad some points'),\n data(gdtrix_comp, 'gamma_inv_data_ipp-gamma_inv_data', (0,1), 3, rtol=6e-15),\n data(gdtrix_comp, 'gamma_inv_big_data_ipp-gamma_inv_big_data', (0,1), 3),\n\n data(chndtr, 'nccs_ipp-nccs', (2,0,1), 3, rtol=3e-5),\n data(chndtr, 'nccs_big_ipp-nccs_big', (2,0,1), 3, rtol=5e-4, knownfailure='chndtr inaccurate some points'),\n\n data(sph_harm_, 'spherical_harmonic_ipp-spherical_harmonic', (1,0,3,2), (4,5), rtol=5e-11,\n param_filter=(lambda p: np.ones(p.shape, '?'),\n lambda p: np.ones(p.shape, '?'),\n lambda p: np.logical_and(p < 2*np.pi, p >= 0),\n lambda p: np.logical_and(p < np.pi, p >= 0))),\n\n data(spherical_jn_, 'sph_bessel_data_ipp-sph_bessel_data', (0,1), 2, rtol=1e-13),\n data(spherical_yn_, 'sph_neumann_data_ipp-sph_neumann_data', (0,1), 2, rtol=8e-15),\n\n data(owens_t, 'owens_t_ipp-owens_t', (0, 1), 2, rtol=5e-14),\n data(owens_t, 'owens_t_large_data_ipp-owens_t_large_data', (0, 1), 2, rtol=8e-12),\n\n # -- test data exists in boost but is not used in scipy --\n\n # ibeta_derivative_data_ipp/ibeta_derivative_data.txt\n # ibeta_derivative_int_data_ipp/ibeta_derivative_int_data.txt\n # ibeta_derivative_large_data_ipp/ibeta_derivative_large_data.txt\n # ibeta_derivative_small_data_ipp/ibeta_derivative_small_data.txt\n\n # bessel_y01_prime_data_ipp/bessel_y01_prime_data.txt\n # bessel_yn_prime_data_ipp/bessel_yn_prime_data.txt\n # sph_bessel_prime_data_ipp/sph_bessel_prime_data.txt\n # sph_neumann_prime_data_ipp/sph_neumann_prime_data.txt\n\n # ellint_d2_data_ipp/ellint_d2_data.txt\n # ellint_d_data_ipp/ellint_d_data.txt\n # ellint_pi2_data_ipp/ellint_pi2_data.txt\n # ellint_pi3_data_ipp/ellint_pi3_data.txt\n # ellint_pi3_large_data_ipp/ellint_pi3_large_data.txt\n data(elliprc, 'ellint_rc_data_ipp-ellint_rc_data', (0, 1), 2,\n rtol=5e-16),\n data(elliprd, 'ellint_rd_data_ipp-ellint_rd_data', (0, 1, 2), 3,\n rtol=5e-16),\n data(elliprd, 'ellint_rd_0xy_ipp-ellint_rd_0xy', (0, 1, 2), 3,\n rtol=5e-16),\n data(elliprd, 'ellint_rd_0yy_ipp-ellint_rd_0yy', (0, 1, 2), 3,\n rtol=5e-16),\n data(elliprd, 'ellint_rd_xxx_ipp-ellint_rd_xxx', (0, 1, 2), 3,\n rtol=5e-16),\n # Some of the following rtol for elliprd may be larger than 5e-16 to\n # work around some hard cases in the Boost test where we get slightly\n # larger error than the ideal bound when the x (==y) input is close to\n # zero.\n # Also the accuracy on 32-bit buids with g++ may suffer from excess\n # loss of precision; see GCC bugzilla 323\n # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=323\n data(elliprd, 'ellint_rd_xxz_ipp-ellint_rd_xxz', (0, 1, 2), 3,\n rtol=6.5e-16),\n data(elliprd, 'ellint_rd_xyy_ipp-ellint_rd_xyy', (0, 1, 2), 3,\n rtol=6e-16),\n data(elliprf, 'ellint_rf_data_ipp-ellint_rf_data', (0, 1, 2), 3,\n rtol=5e-16),\n data(elliprf, 'ellint_rf_xxx_ipp-ellint_rf_xxx', (0, 1, 2), 3,\n rtol=5e-16),\n data(elliprf, 'ellint_rf_xyy_ipp-ellint_rf_xyy', (0, 1, 2), 3,\n rtol=5e-16),\n data(elliprf, 'ellint_rf_xy0_ipp-ellint_rf_xy0', (0, 1, 2), 3,\n rtol=5e-16),\n data(elliprf, 'ellint_rf_0yy_ipp-ellint_rf_0yy', (0, 1, 2), 3,\n rtol=5e-16),\n # The accuracy of R_G is primarily limited by R_D that is used\n # internally. It is generally worse than R_D. Notice that we increased\n # the rtol for R_G here. The cases with duplicate arguments are\n # slightly less likely to be unbalanced (at least two arguments are\n # already balanced) so the error bound is slightly better. Again,\n # precision with g++ 32-bit is even worse.\n data(elliprg, 'ellint_rg_ipp-ellint_rg', (0, 1, 2), 3,\n rtol=8.0e-16),\n data(elliprg, 'ellint_rg_xxx_ipp-ellint_rg_xxx', (0, 1, 2), 3,\n rtol=6e-16),\n data(elliprg, 'ellint_rg_xyy_ipp-ellint_rg_xyy', (0, 1, 2), 3,\n rtol=7.5e-16),\n data(elliprg, 'ellint_rg_xy0_ipp-ellint_rg_xy0', (0, 1, 2), 3,\n rtol=5e-16),\n data(elliprg, 'ellint_rg_00x_ipp-ellint_rg_00x', (0, 1, 2), 3,\n rtol=5e-16),\n data(elliprj, 'ellint_rj_data_ipp-ellint_rj_data', (0, 1, 2, 3), 4,\n rtol=5e-16, atol=1e-25,\n param_filter=(lambda s: s <= 5e-26,)),\n # ellint_rc_data_ipp/ellint_rc_data.txt\n # ellint_rd_0xy_ipp/ellint_rd_0xy.txt\n # ellint_rd_0yy_ipp/ellint_rd_0yy.txt\n # ellint_rd_data_ipp/ellint_rd_data.txt\n # ellint_rd_xxx_ipp/ellint_rd_xxx.txt\n # ellint_rd_xxz_ipp/ellint_rd_xxz.txt\n # ellint_rd_xyy_ipp/ellint_rd_xyy.txt\n # ellint_rf_0yy_ipp/ellint_rf_0yy.txt\n # ellint_rf_data_ipp/ellint_rf_data.txt\n # ellint_rf_xxx_ipp/ellint_rf_xxx.txt\n # ellint_rf_xy0_ipp/ellint_rf_xy0.txt\n # ellint_rf_xyy_ipp/ellint_rf_xyy.txt\n # ellint_rg_00x_ipp/ellint_rg_00x.txt\n # ellint_rg_ipp/ellint_rg.txt\n # ellint_rg_xxx_ipp/ellint_rg_xxx.txt\n # ellint_rg_xy0_ipp/ellint_rg_xy0.txt\n # ellint_rg_xyy_ipp/ellint_rg_xyy.txt\n # ellint_rj_data_ipp/ellint_rj_data.txt\n # ellint_rj_e2_ipp/ellint_rj_e2.txt\n # ellint_rj_e3_ipp/ellint_rj_e3.txt\n # ellint_rj_e4_ipp/ellint_rj_e4.txt\n # ellint_rj_zp_ipp/ellint_rj_zp.txt\n\n # jacobi_elliptic_ipp/jacobi_elliptic.txt\n # jacobi_elliptic_small_ipp/jacobi_elliptic_small.txt\n # jacobi_large_phi_ipp/jacobi_large_phi.txt\n # jacobi_near_1_ipp/jacobi_near_1.txt\n # jacobi_zeta_big_phi_ipp/jacobi_zeta_big_phi.txt\n # jacobi_zeta_data_ipp/jacobi_zeta_data.txt\n\n # heuman_lambda_data_ipp/heuman_lambda_data.txt\n\n # hypergeometric_0F2_ipp/hypergeometric_0F2.txt\n # hypergeometric_1F1_big_ipp/hypergeometric_1F1_big.txt\n # hypergeometric_1F1_ipp/hypergeometric_1F1.txt\n # hypergeometric_1F1_small_random_ipp/hypergeometric_1F1_small_random.txt\n # hypergeometric_1F2_ipp/hypergeometric_1F2.txt\n # hypergeometric_1f1_large_regularized_ipp/hypergeometric_1f1_large_regularized.txt\n # hypergeometric_1f1_log_large_unsolved_ipp/hypergeometric_1f1_log_large_unsolved.txt\n # hypergeometric_2F0_half_ipp/hypergeometric_2F0_half.txt\n # hypergeometric_2F0_integer_a2_ipp/hypergeometric_2F0_integer_a2.txt\n # hypergeometric_2F0_ipp/hypergeometric_2F0.txt\n # hypergeometric_2F0_large_z_ipp/hypergeometric_2F0_large_z.txt\n # hypergeometric_2F1_ipp/hypergeometric_2F1.txt\n # hypergeometric_2F2_ipp/hypergeometric_2F2.txt\n\n # ncbeta_big_ipp/ncbeta_big.txt\n # nct_small_delta_ipp/nct_small_delta.txt\n # nct_asym_ipp/nct_asym.txt\n # ncbeta_ipp/ncbeta.txt\n\n # powm1_data_ipp/powm1_big_data.txt\n # powm1_sqrtp1m1_test_hpp/sqrtp1m1_data.txt\n\n # sinc_data_ipp/sinc_data.txt\n\n # test_gamma_data_ipp/gammap1m1_data.txt\n # tgamma_ratio_data_ipp/tgamma_ratio_data.txt\n\n # trig_data_ipp/trig_data.txt\n # trig_data2_ipp/trig_data2.txt\n]\n\n\[email protected]('test', BOOST_TESTS, ids=repr)\ndef test_boost(test):\n _test_factory(test)\n\n\nGSL_TESTS = [\n data_gsl(mathieu_a, 'mathieu_ab', (0, 1), 2, rtol=1e-13, atol=1e-13),\n data_gsl(mathieu_b, 'mathieu_ab', (0, 1), 3, rtol=1e-13, atol=1e-13),\n\n # Also the GSL output has limited accuracy...\n data_gsl(mathieu_ce_rad, 'mathieu_ce_se', (0, 1, 2), 3, rtol=1e-7, atol=1e-13),\n data_gsl(mathieu_se_rad, 'mathieu_ce_se', (0, 1, 2), 4, rtol=1e-7, atol=1e-13),\n\n data_gsl(mathieu_mc1_scaled, 'mathieu_mc_ms', (0, 1, 2), 3, rtol=1e-7, atol=1e-13),\n data_gsl(mathieu_ms1_scaled, 'mathieu_mc_ms', (0, 1, 2), 4, rtol=1e-7, atol=1e-13),\n\n data_gsl(mathieu_mc2_scaled, 'mathieu_mc_ms', (0, 1, 2), 5, rtol=1e-7, atol=1e-13),\n data_gsl(mathieu_ms2_scaled, 'mathieu_mc_ms', (0, 1, 2), 6, rtol=1e-7, atol=1e-13),\n]\n\n\[email protected]('test', GSL_TESTS, ids=repr)\ndef test_gsl(test):\n _test_factory(test)\n\n\nLOCAL_TESTS = [\n data_local(ellipkinc, 'ellipkinc_neg_m', (0, 1), 2),\n data_local(ellipkm1, 'ellipkm1', 0, 1),\n data_local(ellipeinc, 'ellipeinc_neg_m', (0, 1), 2),\n data_local(clog1p, 'log1p_expm1_complex', (0,1), (2,3), rtol=1e-14),\n data_local(cexpm1, 'log1p_expm1_complex', (0,1), (4,5), rtol=1e-14),\n data_local(gammainc, 'gammainc', (0, 1), 2, rtol=1e-12),\n data_local(gammaincc, 'gammaincc', (0, 1), 2, rtol=1e-11),\n data_local(ellip_harm_2, 'ellip',(0, 1, 2, 3, 4), 6, rtol=1e-10, atol=1e-13),\n data_local(ellip_harm, 'ellip',(0, 1, 2, 3, 4), 5, rtol=1e-10, atol=1e-13),\n]\n\n\[email protected]('test', LOCAL_TESTS, ids=repr)\ndef test_local(test):\n _test_factory(test)\n\n\ndef _test_factory(test, dtype=np.double):\n \"\"\"Boost test\"\"\"\n with suppress_warnings() as sup:\n sup.filter(IntegrationWarning, \"The occurrence of roundoff error is detected\")\n with np.errstate(all='ignore'):\n test.check(dtype=dtype)\n" ]

[ [ "scipy.special.mathieu_modcem1", "scipy.special.mathieu_sem", "scipy.special.zeta", "numpy.sqrt", "scipy.special.expm1", "scipy.special.ellipk", "scipy.special.gdtrib", "scipy.special.mathieu_modcem2", "scipy.special.poch", "scipy.special.bdtrik", "scipy.special.mathieu_modsem1", "numpy.testing.suppress_warnings", "scipy.special.lqmn", "scipy.special.sph_harm", "scipy.special.nbdtrik", "scipy.special.lpmn", "scipy.special.mathieu_cem", "scipy.special.ellipj", "scipy.special.pdtrik", "scipy.special.ellipkinc", "scipy.special.log1p", "scipy.special.gdtrc", "scipy.special._testutils.FuncData", "numpy.errstate", "scipy.special.mathieu_modsem2", "numpy.logical_and", "scipy.special.btdtrib", "scipy.special.btdtria", "scipy.special.ellipeinc", "scipy.special.btdtri", "scipy.special.ellipe", "scipy.special.gdtrix", "numpy.ones", "scipy.special.gdtr", "scipy.special.lpmv" ] ]

dahburj/tf2-gnn

[ "ac6247c44957b35a478de4bbe13c0c96e82f0ba1" ]

[ "tf2_gnn/data/jsonl_graph_dataset.py" ]

[ "\"\"\"General dataset class for datasets stored as JSONLines files.\"\"\"\nimport logging\nfrom typing import Any, Dict, Iterator, List, Optional, Tuple, Set\n\nimport numpy as np\nfrom dpu_utils.utils import RichPath\n\nfrom .graph_dataset import DataFold, GraphDataset, GraphSampleType, GraphSample\n\nlogger = logging.getLogger(__name__)\n\n\nclass JsonLGraphDataset(GraphDataset[GraphSampleType]):\n \"\"\"\n General class representing pre-split datasets in JSONLines format.\n Concretely, this class expects the following:\n * In the data directory, files \"train.jsonl.gz\", \"valid.jsonl.gz\" and\n \"test.jsonl.gz\" are used to store the train/valid/test datasets.\n * Each of the files is gzipped text file in which each line is a valid\n JSON dictionary with a \"graph\" key, which in turn points to a\n dictionary with keys\n - \"node_features\" (list of numerical initial node labels)\n - \"adjacency_lists\" (list of list of directed edge pairs)\n \"\"\"\n\n @classmethod\n def get_default_hyperparameters(cls) -> Dict[str, Any]:\n super_hypers = super().get_default_hyperparameters()\n this_hypers = {\n \"num_fwd_edge_types\": 3,\n \"add_self_loop_edges\": True,\n \"tie_fwd_bkwd_edges\": True,\n }\n super_hypers.update(this_hypers)\n return super_hypers\n\n def __init__(\n self, params: Dict[str, Any], metadata: Optional[Dict[str, Any]] = None,\n ):\n super().__init__(params, metadata=metadata)\n self._params = params\n self._num_fwd_edge_types = params[\"num_fwd_edge_types\"]\n if params[\"tie_fwd_bkwd_edges\"]:\n self._num_edge_types = self._num_fwd_edge_types\n else:\n self._num_edge_types = 2 * self._num_fwd_edge_types\n self._num_edge_types += int(params[\"add_self_loop_edges\"])\n\n self._node_feature_shape: Optional[Tuple[int]] = None\n self._loaded_data: Dict[DataFold, List[GraphSampleType]] = {}\n\n @property\n def num_edge_types(self) -> int:\n return self._num_edge_types\n\n @property\n def node_feature_shape(self) -> Tuple:\n \"\"\"Return the shape of the node features.\"\"\"\n if self._node_feature_shape is None:\n some_data_fold = next(iter(self._loaded_data.values()))\n self._node_feature_shape = (len(some_data_fold[0].node_features[0]),)\n return self._node_feature_shape\n\n def load_metadata(self, path: RichPath) -> None:\n \"\"\"Load the metadata for a dataset (such as vocabularies, names of properties, ...)\n from a path on disk.\n\n Note: Implementors needing to act on metadata information before loading any actual data\n should override this method.\n \"\"\"\n if self.metadata == {}:\n metadata_path = path.join(\"metadata.pkl.gz\")\n if metadata_path.exists():\n logger.info(f\"Loading metadata from {metadata_path}\")\n self._metadata = metadata_path.read_by_file_suffix()\n else:\n logger.warning(\"Using metadata passed to constructor, not metadata stored with data.\")\n\n def load_data(self, path: RichPath, folds_to_load: Optional[Set[DataFold]] = None) -> None:\n \"\"\"Load the data from disk.\"\"\"\n logger.info(f\"Starting to load data from {path}.\")\n self.load_metadata(path)\n\n # If we haven't defined what folds to load, load all:\n if folds_to_load is None:\n folds_to_load = {DataFold.TRAIN, DataFold.VALIDATION, DataFold.TEST}\n\n if DataFold.TRAIN in folds_to_load:\n self._loaded_data[DataFold.TRAIN] = self.__load_data(path.join(\"train.jsonl.gz\"))\n logger.debug(\"Done loading training data.\")\n if DataFold.VALIDATION in folds_to_load:\n self._loaded_data[DataFold.VALIDATION] = self.__load_data(path.join(\"valid.jsonl.gz\"))\n logger.debug(\"Done loading validation data.\")\n if DataFold.TEST in folds_to_load:\n self._loaded_data[DataFold.TEST] = self.__load_data(path.join(\"test.jsonl.gz\"))\n logger.debug(\"Done loading test data.\")\n\n def load_data_from_list(\n self, datapoints: List[Dict[str, Any]], target_fold: DataFold = DataFold.TEST\n ):\n if target_fold not in self._loaded_data:\n self._loaded_data[target_fold] = []\n for datapoint in datapoints:\n self._loaded_data[target_fold].append(self._process_raw_datapoint(datapoint))\n\n def __load_data(self, data_file: RichPath) -> List[GraphSampleType]:\n return [\n self._process_raw_datapoint(datapoint) for datapoint in data_file.read_by_file_suffix()\n ]\n\n def _process_raw_datapoint(self, datapoint: Dict[str, Any]) -> GraphSampleType:\n node_features = datapoint[\"graph\"][\"node_features\"]\n type_to_adj_list, type_to_num_incoming_edges = self._process_raw_adjacency_lists(\n raw_adjacency_lists=datapoint[\"graph\"][\"adjacency_lists\"],\n num_nodes=len(node_features),\n )\n\n return GraphSample(\n adjacency_lists=type_to_adj_list,\n type_to_node_to_num_inedges=type_to_num_incoming_edges,\n node_features=node_features,\n )\n\n def _process_raw_adjacency_lists(\n self, raw_adjacency_lists: List[List[Tuple]], num_nodes: int\n ) -> Tuple[List, np.ndarray]:\n type_to_adj_list = [\n [] for _ in range(self._num_fwd_edge_types + int(self.params[\"add_self_loop_edges\"]))\n ] # type: List[List[Tuple[int, int]]]\n type_to_num_incoming_edges = np.zeros(shape=(self.num_edge_types, num_nodes))\n for raw_edge_type, edges in enumerate(raw_adjacency_lists):\n if self.params[\"add_self_loop_edges\"]:\n fwd_edge_type = raw_edge_type + 1 # 0 will be the self-loop type\n else:\n fwd_edge_type = raw_edge_type # Make edges start from 0\n for src, dest in edges:\n type_to_adj_list[fwd_edge_type].append((src, dest))\n type_to_num_incoming_edges[fwd_edge_type, dest] += 1\n if self.params[\"tie_fwd_bkwd_edges\"]:\n type_to_adj_list[fwd_edge_type].append((dest, src))\n type_to_num_incoming_edges[fwd_edge_type, src] += 1\n\n if self.params[\"add_self_loop_edges\"]:\n # Add self-loop edges (idx 0, which isn't used in the data):\n for node in range(num_nodes):\n type_to_num_incoming_edges[0, node] = 1\n type_to_adj_list[0].append((node, node))\n\n # Add backward edges as an additional edge type that goes backwards:\n if not (self.params[\"tie_fwd_bkwd_edges\"]):\n # for (edge_type, adj_list) in enumerate(type_to_adj_list):\n num_edge_types_in_adj_lists = len(type_to_adj_list)\n for edge_type in range(num_edge_types_in_adj_lists):\n adj_list = type_to_adj_list[edge_type]\n # Don't add self loops again!\n if edge_type == 0 and self.params[\"add_self_loop_edges\"]:\n continue\n bkwd_edge_type = len(type_to_adj_list)\n type_to_adj_list.append([(y, x) for (x, y) in adj_list])\n for (x, y) in adj_list:\n type_to_num_incoming_edges[bkwd_edge_type][y] += 1\n\n # Convert the adjacency lists to numpy arrays.\n type_to_adj_list = [\n np.array(adj_list, dtype=np.int32)\n if len(adj_list) > 0\n else np.zeros(shape=(0, 2), dtype=np.int32)\n for adj_list in type_to_adj_list\n ]\n return type_to_adj_list, type_to_num_incoming_edges\n\n def _graph_iterator(self, data_fold: DataFold) -> Iterator[GraphSampleType]:\n if data_fold == DataFold.TRAIN:\n np.random.shuffle(self._loaded_data[data_fold])\n return iter(self._loaded_data[data_fold])\n" ]

[ [ "numpy.array", "numpy.zeros", "numpy.random.shuffle" ] ]

TheLortex/rust-mcts

[ "10d0700cef7df7059b7cbacc609d173580203fa9" ]

[ "settings.py" ]

[ "\ndef dir_name(config, method):\n if config.game.kind == \"Breakthrough\":\n return \"{}-breakthrough-{}\".format(method, config.game.size)\n elif config.game.kind == \"Gym\":\n return \"{}-gym-{}\".format(method, config.game.name)\n else:\n print(\"Unknown game in config file.\")\n exit(-1)\n\ndef get_board_shape(config):\n if config.game.kind == \"Breakthrough\":\n return (config.game.history, config.game.size, config.game.size, 3)\n elif config.game.kind == \"Gym\":\n if config.game.name == \"Breakout-v0\":\n return (config.game.history, 96, 96, 3)\n else:\n print(\"Gym not implemented for this game.\")\n exit(-1)\n else:\n print(\"Unknown game in config file.\")\n exit(-1)\n\ndef get_action_shape(config):\n if config.game.kind == \"Breakthrough\":\n return (config.game.size, config.game.size, 3)\n elif config.game.kind == \"Gym\":\n if config.game.name == \"Breakout-v0\":\n return (4,)\n else:\n print(\"Gym not implemented for this game.\")\n exit(-1)\n else:\n print(\"Unknown game in config file.\")\n exit(-1)\n\n \nimport numpy as np\n# scalar to categorical transformation.\ndef value_to_support(v, support_size):\n # invertible transformation\n scaled = np.sign(v) * ((np.sqrt(np.abs(v)+1)-1)) + 0.001*v\n # clamp to support\n clamped = np.clip(scaled, -support_size, support_size)\n\n v1 = np.floor(clamped)\n p1 = 1 - (clamped - v1)\n v2 = v1 + 1\n p2 = 1 - p1\n\n result = np.zeros(shape=(support_size*2+1,))\n result[int(v1) + support_size] = p1\n if int(v2) + support_size < support_size*2+1:\n result[int(v2) + support_size] = p2\n return result\n \nfrom tensorflow.keras import losses\ndef mu_loss_unrolled_cce(config):\n def loss(y_true, y_pred):\n policy_loss = 0.\n\n for i in range(config.mu.unroll_steps):\n policy_loss += losses.categorical_crossentropy(\n y_true[:, i], y_pred[:, i]) / config.mu.unroll_steps\n\n return policy_loss\n return loss\n\ndef get_support_shape(x):\n return (x or 0)*2+1\n\"\"\"\n## GAME SETTINGS, make sure this is coherent with the generator and evaluator\nGAME = \"breakthrough\"\n\nif GAME == \"breakthrough\":\n BT_K = 5\n HISTORY_LENGTH = 2\n BOARD_SHAPE = (HISTORY_LENGTH, BT_K, BT_K, 3)\n ACTION_PLANES = 3\n ACTION_SHAPE = (BT_K, BT_K, ACTION_PLANES)\n HIDDEN_PLANES = 16\n HIDDEN_SHAPE = (BT_K, BT_K, HIDDEN_PLANES)\n SUPPORT_SIZE = 1\nelif GAME == \"atari\":\n HISTORY_LENGTH = 8\n BOARD_SHAPE = (HISTORY_LENGTH, 96, 96, 3)\n ACTION_PLANES = 4 # breakout\n ACTION_SHAPE = (ACTION_PLANES, )\n HIDDEN_PLANES = 16\n HIDDEN_SHAPE = (6, 6, HIDDEN_PLANES)\n SUPPORT_SIZE = 300\n\nSUPPORT_SHAPE = 2*SUPPORT_SIZE+1\n\n\n# MUZERO SPECIFIC\nN_UNROLL_STEPS = 5\nN_TD_STEPS = 300\nDISCOUNT = 0.997\n\nWEIGHT_DECAY = 1e-4\n\nREPLAY_BUFFER_SIZE = 5000 # SAVE THE LAST 5k GAMES\nEPOCH_SIZE = 5*REPLAY_BUFFER_SIZE\nBATCH_SIZE = 512\nN_EPOCH = 50000\n\nSAVE_REPLAY_BUFFER_FREQ = 64 # backup replay buffer every _ games\nCHECKPOINT_FREQ = 5*EPOCH_SIZE # save model\nEVALUATION_FREQ = 5*EPOCH_SIZE # evaluate model\n\"\"\"" ]

[ [ "numpy.abs", "numpy.clip", "tensorflow.keras.losses.categorical_crossentropy", "numpy.sign", "numpy.floor", "numpy.zeros" ] ]

makra89/Quake_AI

[ "8df69c75b117079f5e40929341c4638e741de11d" ]

[ "yolov3_tf2/models.py" ]

[ "import numpy as np\nimport tensorflow as tf\nfrom tensorflow.keras import Model\nfrom tensorflow.keras.layers import (\n Add,\n Concatenate,\n Conv2D,\n Input,\n Lambda,\n LeakyReLU,\n MaxPool2D,\n UpSampling2D,\n ZeroPadding2D,\n BatchNormalization,\n)\nfrom tensorflow.keras.regularizers import l2\nfrom tensorflow.keras.losses import (\n binary_crossentropy,\n sparse_categorical_crossentropy\n)\nfrom .utils import broadcast_iou\n\n# TODO: Add these values to config?\nYOLO_MAX_BOXES = 100\nYOLO_IOU_THRESHOLD = 0.5\nYOLO_SCORE_THRESHOLD = 0.5\n\nyolo_anchors = np.array([(10, 13), (16, 30), (33, 23), (30, 61), (62, 45),\n (59, 119), (116, 90), (156, 198), (373, 326)],\n np.float32) / 416\nyolo_anchor_masks = yolo_tiny_3l_anchor_masks = np.array([[6, 7, 8], [3, 4, 5], [0, 1, 2]])\n\nyolo_tiny_3l_anchors = np.array([(11, 20), (15, 31), (16, 56), (24, 44), (27, 70),\n (35, 101), (51, 120), (71, 179), (132, 245)],\n np.float32) / 416\n\n# Determined for custom dataset\nyolo_tiny_anchors = np.array([(14, 28), (22, 54), (30, 87),\n (45, 95), (52, 145), (106, 216)],\n np.float32) / 416\nyolo_tiny_anchor_masks = np.array([[3, 4, 5], [0, 1, 2]])\n\n\ndef DarknetConv(x, filters, size, strides=1, batch_norm=True):\n if strides == 1:\n padding = 'same'\n else:\n x = ZeroPadding2D(((1, 0), (1, 0)))(x) # top left half-padding\n padding = 'valid'\n x = Conv2D(filters=filters, kernel_size=size,\n strides=strides, padding=padding,\n use_bias=not batch_norm, kernel_regularizer=l2(0.0005))(x)\n if batch_norm:\n x = BatchNormalization()(x)\n x = LeakyReLU(alpha=0.1)(x)\n return x\n\n\ndef DarknetResidual(x, filters):\n prev = x\n x = DarknetConv(x, filters // 2, 1)\n x = DarknetConv(x, filters, 3)\n x = Add()([prev, x])\n return x\n\n\ndef DarknetBlock(x, filters, blocks):\n x = DarknetConv(x, filters, 3, strides=2)\n for _ in range(blocks):\n x = DarknetResidual(x, filters)\n return x\n\n\ndef Darknet(name=None):\n x = inputs = Input([None, None, 3])\n x = DarknetConv(x, 32, 3)\n x = DarknetBlock(x, 64, 1)\n x = DarknetBlock(x, 128, 2) # skip connection\n x = x_36 = DarknetBlock(x, 256, 8) # skip connection\n x = x_61 = DarknetBlock(x, 512, 8)\n x = DarknetBlock(x, 1024, 4)\n return tf.keras.Model(inputs, (x_36, x_61, x), name=name)\n\n\ndef DarknetTiny(name=None):\n x = inputs = Input([None, None, 3])\n x = DarknetConv(x, 16, 3)\n x = MaxPool2D(2, 2, 'same')(x)\n x = DarknetConv(x, 32, 3)\n x = MaxPool2D(2, 2, 'same')(x)\n x = DarknetConv(x, 64, 3)\n x = MaxPool2D(2, 2, 'same')(x)\n x = DarknetConv(x, 128, 3)\n x = MaxPool2D(2, 2, 'same')(x)\n x = x_8 = DarknetConv(x, 256, 3) # skip connection\n x = MaxPool2D(2, 2, 'same')(x)\n x = DarknetConv(x, 512, 3)\n x = MaxPool2D(2, 1, 'same')(x)\n x = DarknetConv(x, 1024, 3)\n return tf.keras.Model(inputs, (x_8, x), name=name)\n\ndef DarknetTiny3L(name=None):\n x = inputs = Input([None, None, 3])\n x = DarknetConv(x, 16, 3)\n x = MaxPool2D(2, 2, 'same')(x)\n x = DarknetConv(x, 32, 3)\n x = MaxPool2D(2, 2, 'same')(x)\n x = DarknetConv(x, 64, 3)\n x = MaxPool2D(2, 2, 'same')(x)\n x = x_6 = DarknetConv(x, 128, 3)\n x = MaxPool2D(2, 2, 'same')(x)\n x = x_8 = DarknetConv(x, 256, 3) # skip connection\n x = MaxPool2D(2, 2, 'same')(x)\n x = DarknetConv(x, 512, 3)\n x = MaxPool2D(2, 1, 'same')(x)\n x = DarknetConv(x, 1024, 3)\n return tf.keras.Model(inputs, (x_6, x_8, x), name=name)\n\n\ndef YoloConv(filters, name=None):\n def yolo_conv(x_in):\n if isinstance(x_in, tuple):\n inputs = Input(x_in[0].shape[1:]), Input(x_in[1].shape[1:])\n x, x_skip = inputs\n\n # concat with skip connection\n x = DarknetConv(x, filters, 1)\n x = UpSampling2D(2)(x)\n x = Concatenate()([x, x_skip])\n else:\n x = inputs = Input(x_in.shape[1:])\n\n x = DarknetConv(x, filters, 1)\n x = DarknetConv(x, filters * 2, 3)\n x = DarknetConv(x, filters, 1)\n x = DarknetConv(x, filters * 2, 3)\n x = DarknetConv(x, filters, 1)\n return Model(inputs, x, name=name)(x_in)\n return yolo_conv\n\n\ndef YoloConvTiny(filters, name=None):\n def yolo_conv(x_in):\n if isinstance(x_in, tuple):\n inputs = Input(x_in[0].shape[1:]), Input(x_in[1].shape[1:])\n x, x_skip = inputs\n\n # concat with skip connection\n x = DarknetConv(x, filters, 1)\n x = UpSampling2D(2)(x)\n x = Concatenate()([x, x_skip])\n else:\n x = inputs = Input(x_in.shape[1:])\n x = DarknetConv(x, filters, 1)\n\n return Model(inputs, x, name=name)(x_in)\n return yolo_conv\n\n\ndef YoloOutput(filters, anchors, classes, name=None):\n def yolo_output(x_in):\n x = inputs = Input(x_in.shape[1:])\n x = DarknetConv(x, filters * 2, 3)\n x = DarknetConv(x, anchors * (classes + 5), 1, batch_norm=False)\n x = Lambda(lambda x: tf.reshape(x, (-1, tf.shape(x)[1], tf.shape(x)[2],\n anchors, classes + 5)))(x)\n return tf.keras.Model(inputs, x, name=name)(x_in)\n return yolo_output\n\n\n# As tensorflow lite doesn't support tf.size used in tf.meshgrid, \n# we reimplemented a simple meshgrid function that use basic tf function.\ndef _meshgrid(n_a, n_b):\n\n return [\n tf.reshape(tf.tile(tf.range(n_a), [n_b]), (n_b, n_a)),\n tf.reshape(tf.repeat(tf.range(n_b), n_a), (n_b, n_a))\n ]\n\n\ndef yolo_boxes(pred, anchors, classes):\n # pred: (batch_size, grid, grid, anchors, (x, y, w, h, obj, ...classes))\n grid_size = tf.shape(pred)[1:3]\n box_xy, box_wh, objectness, class_probs = tf.split(\n pred, (2, 2, 1, classes), axis=-1)\n\n box_xy = tf.sigmoid(box_xy)\n objectness = tf.sigmoid(objectness)\n class_probs = tf.sigmoid(class_probs)\n pred_box = tf.concat((box_xy, box_wh), axis=-1) # original xywh for loss\n\n # !!! grid[x][y] == (y, x)\n grid = _meshgrid(grid_size[1],grid_size[0])\n grid = tf.expand_dims(tf.stack(grid, axis=-1), axis=2) # [gx, gy, 1, 2]\n\n box_xy = (box_xy + tf.cast(grid, tf.float32)) / \\\n tf.cast(grid_size, tf.float32)\n box_wh = tf.exp(box_wh) * anchors\n\n box_x1y1 = box_xy - box_wh / 2\n box_x2y2 = box_xy + box_wh / 2\n bbox = tf.concat([box_x1y1, box_x2y2], axis=-1)\n\n return bbox, objectness, class_probs, pred_box\n\n\ndef yolo_nms(outputs, anchors, masks, classes):\n # boxes, conf, type\n b, c, t = [], [], []\n\n for o in outputs:\n b.append(tf.reshape(o[0], (tf.shape(o[0])[0], -1, tf.shape(o[0])[-1])))\n c.append(tf.reshape(o[1], (tf.shape(o[1])[0], -1, tf.shape(o[1])[-1])))\n t.append(tf.reshape(o[2], (tf.shape(o[2])[0], -1, tf.shape(o[2])[-1])))\n\n bbox = tf.concat(b, axis=1)\n confidence = tf.concat(c, axis=1)\n class_probs = tf.concat(t, axis=1)\n\n # If we only have one class, do not multiply by class_prob (always 0.5)\n if classes == 1:\n scores = confidence\n else:\n scores = confidence * class_probs\n\n dscores = tf.squeeze(scores, axis=0)\n scores = tf.reduce_max(dscores,[1])\n bbox = tf.reshape(bbox,(-1,4))\n classes = tf.argmax(dscores,1)\n selected_indices, selected_scores = tf.image.non_max_suppression_with_scores(\n boxes=bbox,\n scores=scores,\n max_output_size=YOLO_MAX_BOXES,\n iou_threshold=YOLO_IOU_THRESHOLD,\n score_threshold=YOLO_SCORE_THRESHOLD,\n soft_nms_sigma=0.5\n )\n \n num_valid_nms_boxes = tf.shape(selected_indices)[0]\n\n selected_indices = tf.concat([selected_indices,tf.zeros(YOLO_MAX_BOXES-num_valid_nms_boxes, tf.int32)], 0)\n selected_scores = tf.concat([selected_scores,tf.zeros(YOLO_MAX_BOXES-num_valid_nms_boxes,tf.float32)], -1)\n\n boxes=tf.gather(bbox, selected_indices)\n boxes = tf.expand_dims(boxes, axis=0)\n scores=selected_scores\n scores = tf.expand_dims(scores, axis=0)\n classes = tf.gather(classes,selected_indices)\n classes = tf.expand_dims(classes, axis=0)\n valid_detections=num_valid_nms_boxes\n valid_detections = tf.expand_dims(valid_detections, axis=0)\n\n return boxes, scores, classes, valid_detections\n\n\ndef YoloV3(size=None, channels=3, anchors=yolo_anchors,\n masks=yolo_anchor_masks, classes=80, training=False):\n x = inputs = Input([size, size, channels], name='input')\n\n x_36, x_61, x = Darknet(name='yolo_darknet')(x)\n\n x = YoloConv(512, name='yolo_conv_0')(x)\n output_0 = YoloOutput(512, len(masks[0]), classes, name='yolo_output_0')(x)\n\n x = YoloConv(256, name='yolo_conv_1')((x, x_61))\n output_1 = YoloOutput(256, len(masks[1]), classes, name='yolo_output_1')(x)\n\n x = YoloConv(128, name='yolo_conv_2')((x, x_36))\n output_2 = YoloOutput(128, len(masks[2]), classes, name='yolo_output_2')(x)\n\n if training:\n return Model(inputs, (output_0, output_1, output_2), name='yolov3')\n\n boxes_0 = Lambda(lambda x: yolo_boxes(x, anchors[masks[0]], classes),\n name='yolo_boxes_0')(output_0)\n boxes_1 = Lambda(lambda x: yolo_boxes(x, anchors[masks[1]], classes),\n name='yolo_boxes_1')(output_1)\n boxes_2 = Lambda(lambda x: yolo_boxes(x, anchors[masks[2]], classes),\n name='yolo_boxes_2')(output_2)\n\n outputs = Lambda(lambda x: yolo_nms(x, anchors, masks, classes),\n name='yolo_nms')((boxes_0[:3], boxes_1[:3], boxes_2[:3]))\n\n return Model(inputs, outputs, name='yolov3')\n\n\ndef YoloV3Tiny(size=None, channels=3, anchors=yolo_tiny_anchors,\n masks=yolo_tiny_anchor_masks, classes=80, training=False):\n x = inputs = Input([size, size, channels], name='input')\n\n x_8, x = DarknetTiny(name='yolo_darknet')(x)\n\n x = YoloConvTiny(256, name='yolo_conv_0')(x)\n output_0 = YoloOutput(256, len(masks[0]), classes, name='yolo_output_0')(x)\n\n x = YoloConvTiny(128, name='yolo_conv_1')((x, x_8))\n output_1 = YoloOutput(128, len(masks[1]), classes, name='yolo_output_1')(x)\n\n if training:\n return Model(inputs, (output_0, output_1), name='yolov3')\n\n boxes_0 = Lambda(lambda x: yolo_boxes(x, anchors[masks[0]], classes),\n name='yolo_boxes_0')(output_0)\n boxes_1 = Lambda(lambda x: yolo_boxes(x, anchors[masks[1]], classes),\n name='yolo_boxes_1')(output_1)\n outputs = Lambda(lambda x: yolo_nms(x, anchors, masks, classes),\n name='yolo_nms')((boxes_0[:3], boxes_1[:3]))\n return Model(inputs, outputs, name='yolov3_tiny')\n\n\ndef YoloV3Tiny3L(size=None, channels=3, anchors=yolo_tiny_3l_anchors,\n masks=yolo_tiny_3l_anchor_masks, classes=80, training=False):\n x = inputs = Input([size, size, channels], name='input')\n\n x_6, x_8, x = DarknetTiny3L(name='yolo_darknet')(x)\n\n x = YoloConvTiny(256, name='yolo_conv_0')(x)\n output_0 = YoloOutput(256, len(masks[0]), classes, name='yolo_output_0')(x)\n\n x = YoloConvTiny(128, name='yolo_conv_1')((x, x_8))\n output_1 = YoloOutput(128, len(masks[1]), classes, name='yolo_output_1')(x)\n\n x = YoloConvTiny(128, name='yolo_conv_2')((x, x_6))\n output_2 = YoloOutput(64, len(masks[2]), classes, name='yolo_output_2')(x)\n\n if training:\n return Model(inputs, (output_0, output_1, output_2), name='yolov3')\n\n boxes_0 = Lambda(lambda x: yolo_boxes(x, anchors[masks[0]], classes),\n name='yolo_boxes_0')(output_0)\n boxes_1 = Lambda(lambda x: yolo_boxes(x, anchors[masks[1]], classes),\n name='yolo_boxes_1')(output_1)\n boxes_2 = Lambda(lambda x: yolo_boxes(x, anchors[masks[2]], classes),\n name='yolo_boxes_2')(output_2)\n\n outputs = Lambda(lambda x: yolo_nms(x, anchors, masks, classes),\n name='yolo_nms')((boxes_0[:3], boxes_1[:3], boxes_2[:3]))\n\n return Model(inputs, outputs, name='yolov3_tiny_3l')\n\ndef YoloLoss(anchors, classes=80, ignore_thresh=0.5):\n def yolo_loss(y_true, y_pred):\n # 1. transform all pred outputs\n # y_pred: (batch_size, grid, grid, anchors, (x, y, w, h, obj, ...cls))\n pred_box, pred_obj, pred_class, pred_xywh = yolo_boxes(\n y_pred, anchors, classes)\n pred_xy = pred_xywh[..., 0:2]\n pred_wh = pred_xywh[..., 2:4]\n\n # 2. transform all true outputs\n # y_true: (batch_size, grid, grid, anchors, (x1, y1, x2, y2, obj, cls))\n true_box, true_obj, true_class_idx = tf.split(\n y_true, (4, 1, 1), axis=-1)\n true_xy = (true_box[..., 0:2] + true_box[..., 2:4]) / 2\n true_wh = true_box[..., 2:4] - true_box[..., 0:2]\n\n # give higher weights to small boxes\n box_loss_scale = 2 - true_wh[..., 0] * true_wh[..., 1]\n\n # 3. inverting the pred box equations\n grid_size = tf.shape(y_true)[1]\n grid = tf.meshgrid(tf.range(grid_size), tf.range(grid_size))\n grid = tf.expand_dims(tf.stack(grid, axis=-1), axis=2)\n true_xy = true_xy * tf.cast(grid_size, tf.float32) - \\\n tf.cast(grid, tf.float32)\n true_wh = tf.math.log(true_wh / anchors)\n true_wh = tf.where(tf.math.is_inf(true_wh),\n tf.zeros_like(true_wh), true_wh)\n\n # 4. calculate all masks\n obj_mask = tf.squeeze(true_obj, -1)\n # ignore false positive when iou is over threshold\n best_iou = tf.map_fn(\n lambda x: tf.reduce_max(broadcast_iou(x[0], tf.boolean_mask(\n x[1], tf.cast(x[2], tf.bool))), axis=-1),\n (pred_box, true_box, obj_mask),\n tf.float32)\n ignore_mask = tf.cast(best_iou < ignore_thresh, tf.float32)\n\n # 5. calculate all losses\n xy_loss = obj_mask * box_loss_scale * \\\n tf.reduce_sum(tf.square(true_xy - pred_xy), axis=-1)\n wh_loss = obj_mask * box_loss_scale * \\\n tf.reduce_sum(tf.square(true_wh - pred_wh), axis=-1)\n obj_loss = binary_crossentropy(true_obj, pred_obj)\n obj_loss = obj_mask * obj_loss + \\\n (1 - obj_mask) * ignore_mask * obj_loss\n class_loss = obj_mask * sparse_categorical_crossentropy(\n true_class_idx, pred_class)\n\n # 6. sum over (batch, gridx, gridy, anchors) => (batch, 1)\n xy_loss = tf.reduce_sum(xy_loss, axis=(1, 2, 3))\n wh_loss = tf.reduce_sum(wh_loss, axis=(1, 2, 3))\n obj_loss = tf.reduce_sum(obj_loss, axis=(1, 2, 3))\n class_loss = tf.reduce_sum(class_loss, axis=(1, 2, 3))\n\n return xy_loss + wh_loss + obj_loss + class_loss\n return yolo_loss\n" ]

[ [ "tensorflow.concat", "tensorflow.zeros", "tensorflow.stack", "tensorflow.reduce_sum", "tensorflow.cast", "tensorflow.keras.layers.ZeroPadding2D", "tensorflow.keras.layers.Concatenate", "tensorflow.keras.layers.LeakyReLU", "tensorflow.keras.regularizers.l2", "tensorflow.keras.layers.UpSampling2D", "tensorflow.squeeze", "tensorflow.gather", "tensorflow.square", "tensorflow.keras.layers.Add", "tensorflow.argmax", "tensorflow.math.is_inf", "tensorflow.shape", "tensorflow.keras.losses.sparse_categorical_crossentropy", "tensorflow.exp", "tensorflow.keras.Model", "tensorflow.zeros_like", "tensorflow.keras.losses.binary_crossentropy", "tensorflow.split", "numpy.array", "tensorflow.reduce_max", "tensorflow.range", "tensorflow.reshape", "tensorflow.sigmoid", "tensorflow.expand_dims", "tensorflow.image.non_max_suppression_with_scores", "tensorflow.keras.layers.MaxPool2D", "tensorflow.math.log", "tensorflow.keras.layers.BatchNormalization", "tensorflow.keras.layers.Input" ] ]

ASVincent/wagl

[ "cf3a72e53e53f3a7b2f2b5308068069b1b714f2a" ]

[ "wagl/data.py" ]

[ "\"\"\"\nData access functions\n---------------------\n\"\"\"\n\nfrom __future__ import absolute_import\nfrom os.path import join as pjoin, basename, dirname\nimport subprocess\nimport tempfile\nimport logging\nimport numpy as np\nimport h5py\nimport rasterio\n\nfrom rasterio.crs import CRS\nfrom rasterio.warp import reproject\nfrom rasterio.enums import Resampling\nfrom wagl.geobox import GriddedGeoBox\nfrom wagl.tiling import generate_tiles\n\n\ndef get_pixel(filename, lonlat, band=1):\n \"\"\"Return a pixel from `filename` at the longitude and latitude given\n by the tuple `lonlat`. Optionally, the `band` can be specified.\"\"\"\n with rasterio.open(filename) as src:\n x, y = [int(v) for v in ~src.transform * lonlat]\n if isinstance(band, list):\n data = src.read(band, window=((y, y + 1), (x, x + 1))).ravel()\n else:\n data = src.read(band, window=((y, y + 1), (x, x + 1))).flat[0]\n return data\n\n\ndef select_acquisitions(acqs_list, fn=(lambda acq: True)):\n \"\"\"\n Given a list of acquisitions, apply the supplied fn to select the\n desired acquisitions.\n \"\"\"\n acqs = [acq for acq in acqs_list if fn(acq)]\n return acqs\n\n\ndef stack_data(acqs_list, fn=(lambda acq: True), window=None, masked=False):\n \"\"\"\n Given a list of acquisitions, return the data from each acquisition\n collected in a 3D numpy array (first index is the acquisition number).\n If window is defined, then the subset contained within the window is\n returned along with a GriddedGeoBox instance detailing the \n spatial information associated with that subset.\n\n :param acqs_list:\n The list of acquisitions from which to generate a stack of data.\n\n :param window:\n Defines a subset ((ystart, yend), (xstart, xend)) in array\n co-ordinates. Default is None.\n\n :param masked:\n Indicates whether or not to return a masked array. Default is False.\n\n :return:\n A 2-tuple containing:\n\n * 1. A 3D numpy array (or None) containing the corresponding\n acquisition data. (None if no data).\n * 2. A GriddedGeoBox instance specifying the spatial context\n of the 3D numpy array. Note: All Acquisitions share the\n same GriddedGeoBox.\n \"\"\"\n # determine data type and dimensions by reading the first band\n acqs = acqs_list\n a, geo_box = acqs[0].data_and_box(window=window, masked=masked)\n\n # create the result array, setting datatype based on source type\n\n stack_shape = (len(acqs), a.shape[0], a.shape[1])\n stack = np.empty(stack_shape, a.dtype)\n stack[0] = a\n del a\n\n # read remaining aquisitions into it\n\n for i in range(1, stack_shape[0]):\n # can't use this statement because it will cause data to be\n # resampled. But we want an exception thrown if the user\n # tries to stack irreqular aquisitions\n stack[i] = acqs[i].data(window=window, masked=masked)\n\n return stack, geo_box\n\n\ndef write_img(array, filename, driver='GTiff', geobox=None, nodata=None,\n tags=None, options=None, cogtif=False, levels=None,\n resampling=Resampling.nearest):\n \"\"\"\n Writes a 2D/3D image to disk using rasterio.\n\n :param array:\n A 2D/3D NumPy array.\n\n :param filename:\n A string containing the output file name.\n\n :param driver:\n A string containing a GDAL compliant image driver. Default is\n 'GTiff'.\n\n :param geobox:\n An instance of a GriddedGeoBox object.\n\n :param nodata:\n A value representing the no data value for the array.\n\n :param tags:\n A dictionary of dataset-level metadata.\n\n :param options:\n A dictionary containing other dataset creation options.\n See creation options for the respective GDAL formats.\n\n :param cogtif:\n If set to True, override the `driver` keyword with `GTiff`\n and create a Cloud Optimised GeoTiff. Default is False.\n See:\n https://trac.osgeo.org/gdal/wiki/CloudOptimizedGeoTIFF\n\n :param levels:\n If cogtif is set to True, build overviews/pyramids\n according to levels. Default levels are [2, 4, 8, 16, 32].\n\n :param resampling:\n If cogtif is set to True, build overviews/pyramids using\n a resampling method from `rasterio.enums.Resampling`.\n Default is `Resampling.nearest`.\n\n :notes:\n If array is an instance of a `h5py.Dataset`, then the output\n file will include blocksizes based on the `h5py.Dataset's`\n chunks. To override the blocksizes, specify them using the\n `options` keyword. Eg {'blockxsize': 512, 'blockysize': 512}.\n If `cogtif` is set to True, the default blocksizes will be\n 256x256. To override this behaviour, specify them using the\n `options` keyword. Eg {'blockxsize': 512, 'blockysize': 512}.\n \"\"\"\n # Get the datatype of the array\n dtype = array.dtype.name\n\n # Check for excluded datatypes\n excluded_dtypes = ['int64', 'int8', 'uint64']\n if dtype in excluded_dtypes:\n msg = \"Datatype not supported: {dt}\".format(dt=dtype)\n raise TypeError(msg)\n\n # convert any bools to uin8\n if dtype == 'bool':\n array = np.uint8(array)\n dtype = 'uint8'\n\n ndims = array.ndim\n dims = array.shape\n\n # Get the (z, y, x) dimensions (assuming BSQ interleave)\n if ndims == 2:\n samples = dims[1]\n lines = dims[0]\n bands = 1\n elif ndims == 3:\n samples = dims[2]\n lines = dims[1]\n bands = dims[0]\n else:\n logging.error('Input array is not of 2 or 3 dimensions!!!')\n err = 'Array dimensions: {dims}'.format(dims=ndims)\n raise IndexError(err)\n\n # If we have a geobox, then retrieve the geotransform and projection\n if geobox is not None:\n transform = geobox.transform\n projection = geobox.crs.ExportToWkt()\n else:\n transform = None\n projection = None\n\n # override the driver if we are creating a cogtif\n if cogtif:\n driver = 'GTiff'\n\n # compression predictor choices\n predictor = {'int8': 2,\n 'uint8': 2,\n 'int16': 2,\n 'uint16': 2,\n 'int32': 2,\n 'uint32': 2,\n 'int64': 2,\n 'uint64': 2,\n 'float32': 3,\n 'float64': 3}\n\n kwargs = {'count': bands,\n 'width': samples,\n 'height': lines,\n 'crs': projection,\n 'transform': transform,\n 'dtype': dtype,\n 'driver': driver,\n 'nodata': nodata,\n 'predictor': predictor[dtype]}\n\n if isinstance(array, h5py.Dataset):\n # TODO: if array is 3D get x & y chunks\n if array.chunks[1] == array.shape[1]:\n # GDAL doesn't like tiled or blocksize options to be set\n # the same length as the columns (probably true for rows as well)\n array = array[:]\n else:\n y_tile, x_tile = array.chunks\n tiles = generate_tiles(samples, lines, x_tile, y_tile)\n\n # add blocksizes to the creation keywords\n kwargs['tiled'] = 'yes'\n kwargs['blockxsize'] = x_tile\n kwargs['blockysize'] = y_tile\n\n # the user can override any derived blocksizes by supplying `options`\n if options is not None:\n for key in options:\n kwargs[key] = options[key]\n\n with tempfile.TemporaryDirectory() as tmpdir:\n out_fname = pjoin(tmpdir, basename(filename)) if cogtif else filename\n\n with rasterio.open(out_fname, 'w', **kwargs) as outds:\n if bands == 1:\n if isinstance(array, h5py.Dataset):\n for tile in tiles:\n idx = (slice(tile[0][0], tile[0][1]),\n slice(tile[1][0], tile[1][1]))\n outds.write(array[idx], 1, window=tile)\n else:\n outds.write(array, 1)\n else:\n if isinstance(array, h5py.Dataset):\n for tile in tiles:\n idx = (slice(tile[0][0], tile[0][1]),\n slice(tile[1][0], tile[1][1]))\n subs = array[:, idx[0], idx[1]]\n for i in range(bands):\n outds.write(subs[i], i + 1, window=tile)\n else:\n for i in range(bands):\n outds.write(array[i], i + 1)\n if tags is not None:\n outds.update_tags(**tags)\n\n # overviews/pyramids\n if cogtif:\n if levels is None:\n levels = [2, 4, 8, 16, 32]\n outds.build_overviews(levels, resampling)\n\n if cogtif:\n cmd = ['gdal_translate',\n '-co',\n 'TILED=YES',\n '-co',\n 'COPY_SRC_OVERVIEWS=YES',\n '-co',\n '{}={}'.format('PREDICTOR', predictor[dtype])]\n\n for key, value in options.items():\n cmd.extend(['-co', '{}={}'.format(key, value)])\n\n cmd.extend([out_fname, filename])\n\n subprocess.check_call(cmd, cwd=dirname(filename))\n\n\ndef read_subset(fname, ul_xy, ur_xy, lr_xy, ll_xy, bands=1):\n \"\"\"\n Return a 2D or 3D NumPy array subsetted to the given bounding\n extents.\n\n :param fname:\n A string containing the full file pathname to an image on\n disk.\n\n :param ul_xy:\n A tuple containing the Upper Left (x,y) co-ordinate pair\n in real world (map) co-ordinates. Co-ordinate pairs can be\n (longitude, latitude) or (eastings, northings), but they must\n be of the same reference as the image of interest.\n\n :param ur_xy:\n A tuple containing the Upper Right (x,y) co-ordinate pair\n in real world (map) co-ordinates. Co-ordinate pairs can be\n (longitude, latitude) or (eastings, northings), but they must\n be of the same reference as the image of interest.\n\n :param lr_xy:\n A tuple containing the Lower Right (x,y) co-ordinate pair\n in real world (map) co-ordinates. Co-ordinate pairs can be\n (longitude, latitude) or (eastings, northings), but they must\n be of the same reference as the image of interest.\n\n :param ll_xy:\n A tuple containing the Lower Left (x,y) co-ordinate pair\n in real world (map) co-ordinates. Co-ordinate pairs can be\n (longitude, latitude) or (eastings, northings), but they must\n be of the same reference as the image of interest.\n\n :param bands:\n Can be an integer of list of integers representing the band(s)\n to be read from disk. If bands is a list, then the returned\n subset will be 3D, otherwise the subset will be strictly 2D.\n\n :return:\n A tuple of 3 elements:\n\n * 1. 2D or 3D NumPy array containing the image subset.\n * 2. A list of length 6 containing the GDAL geotransform.\n * 3. A WKT formatted string representing the co-ordinate\n reference system (projection).\n\n :additional notes:\n The ending array co-ordinates are increased by +1,\n i.e. xend = 270 + 1\n to account for Python's [inclusive, exclusive) index notation.\n \"\"\"\n if isinstance(fname, h5py.Dataset):\n geobox = GriddedGeoBox.from_dataset(fname)\n prj = fname.attrs['crs_wkt']\n else:\n # Open the file\n with rasterio.open(fname) as src:\n\n # Get the inverse transform of the affine co-ordinate reference\n geobox = GriddedGeoBox.from_dataset(src)\n prj = src.crs.wkt # rasterio returns a unicode\n\n inv = ~geobox.transform\n rows, cols = geobox.shape\n\n # Convert each map co-ordinate to image/array co-ordinates\n img_ul_x, img_ul_y = [int(v) for v in inv * ul_xy]\n img_ur_x, img_ur_y = [int(v) for v in inv * ur_xy]\n img_lr_x, img_lr_y = [int(v) for v in inv * lr_xy]\n img_ll_x, img_ll_y = [int(v) for v in inv * ll_xy]\n\n # Calculate the min and max array extents\n # The ending array extents have +1 to account for Python's\n # [inclusive, exclusive) index notation.\n xstart = min(img_ul_x, img_ll_x)\n ystart = min(img_ul_y, img_ur_y)\n xend = max(img_ur_x, img_lr_x) + 1\n yend = max(img_ll_y, img_lr_y) + 1\n\n # Check for out of bounds\n if (((xstart < 0) or (ystart < 0)) or\n ((xend -1 > cols) or (yend -1 > rows))):\n\n msg = (\"Error! Attempt to read a subset that is outside of the\"\n \"image domain. Index: ({ys}, {ye}), ({xs}, {xe}))\")\n msg = msg.format(ys=ystart, ye=yend, xs=xstart, xe=xend)\n raise IndexError(msg)\n\n if isinstance(fname, h5py.Dataset):\n subs = fname[ystart:yend, xstart:xend]\n else:\n with rasterio.open(fname) as src:\n subs = src.read(bands, window=((ystart, yend), (xstart, xend)))\n\n # Get the new UL co-ordinates of the array\n ul_x, ul_y = geobox.transform * (xstart, ystart)\n\n geobox_subs = GriddedGeoBox(shape=subs.shape, origin=(ul_x, ul_y),\n pixelsize=geobox.pixelsize, crs=prj)\n\n return (subs, geobox_subs)\n\n\ndef reproject_file_to_array(src_filename, src_band=1, dst_geobox=None,\n resampling=Resampling.nearest):\n \"\"\"\n Given an image on file, reproject to the desired coordinate\n reference system.\n\n :param src_filename:\n A string containing the full file path name to the source\n image on disk.\n\n :param src_band:\n An integer representing the band number to be reprojected.\n Default is 1, the 1st band.\n\n :param dst_geobox:\n An instance of a GriddedGeoBox object containing the\n destination parameters such as origin, affine, projection,\n and array dimensions.\n\n :param resampling:\n An integer representing the resampling method to be used.\n check rasterio.warp.RESMPLING for more details.\n Default is 0, nearest neighbour resampling.\n\n :return:\n A NumPy array containing the reprojected result.\n \"\"\"\n\n if not isinstance(dst_geobox, GriddedGeoBox):\n msg = 'dst_geobox must be an instance of a GriddedGeoBox! Type: {}'\n msg = msg.format(type(dst_geobox))\n raise TypeError(msg)\n\n with rasterio.open(src_filename) as src:\n # Define a rasterio band\n rio_band = rasterio.band(src, src_band)\n\n # Define the output NumPy array\n dst_arr = np.zeros(dst_geobox.shape, dtype=src.dtypes[0])\n\n # Get the rasterio proj4 styled dict\n prj = CRS.from_string(dst_geobox.crs.ExportToProj4())\n\n reproject(rio_band, dst_arr, dst_transform=dst_geobox.transform,\n dst_crs=prj, resampling=resampling)\n\n return dst_arr\n\n\ndef reproject_img_to_img(src_img, src_geobox, dst_geobox,\n resampling=Resampling.nearest):\n \"\"\"\n Reprojects an image/array to the desired co-ordinate reference system.\n\n :param src_img:\n A NumPy array containing the source image.\n\n :param src_geobox:\n An instance of a GriddedGeoBox object containing the\n source parameters such as origin, affine, projection.\n\n :param dst_geobox:\n An instance of a GriddedGeoBox object containing the\n destination parameters such as origin, affine, projection,\n and array dimensions.\n\n :param resampling:\n An integer representing the resampling method to be used.\n check rasterio.warp.RESMPLING for more details.\n Default is 0, nearest neighbour resampling.\n\n :return:\n A NumPy array containing the reprojected result.\n \"\"\"\n\n if not isinstance(dst_geobox, GriddedGeoBox):\n msg = 'dst_geobox must be an instance of a GriddedGeoBox! Type: {}'\n msg = msg.format(type(dst_geobox))\n raise TypeError(msg)\n\n if not isinstance(src_geobox, GriddedGeoBox):\n msg = 'src_geobox must be an instance of a GriddedGeoBox! Type: {}'\n msg = msg.format(type(src_geobox))\n raise TypeError(msg)\n\n # Get the source and destination projections in Proj4 styled dicts\n src_prj = CRS.from_string(src_geobox.crs.ExportToProj4())\n dst_prj = CRS.from_string(dst_geobox.crs.ExportToProj4())\n\n # Get the source and destination transforms\n src_trans = src_geobox.transform\n dst_trans = dst_geobox.transform\n\n # Define the output NumPy array\n dst_arr = np.zeros(dst_geobox.shape, dtype=src_img.dtype)\n\n reproject(src_img, dst_arr, src_transform=src_trans,\n src_crs=src_prj, dst_transform=dst_trans, dst_crs=dst_prj,\n resampling=resampling)\n\n return dst_arr\n\n\ndef as_array(array, dtype, transpose=False):\n \"\"\"\n Given an array and dtype, array will be converted to dtype if\n and only if array.dtype != dtype. If transpose is set to True\n then array will be transposed before returning.\n\n :param array:\n A NumPy array.\n\n :param dtype:\n The type to return the array as.\n :type dtype:\n A NumPy data type (e.g. ``numpy.float32``).\n\n :param transpose:\n If set then array will be transposed before returning.\n Useful for passing arrays into Fortran routiines. Default is\n False.\n :type transpose:\n Bool.\n\n :return:\n A :py:class:`numpy.ndarry` of type ``dtype`` with the same\n dimensions as array.\n \"\"\"\n if array.dtype != dtype:\n if transpose:\n return array.astype(dtype).transpose()\n return array.astype(dtype)\n if transpose:\n return array.transpose()\n return array\n" ]

[ [ "numpy.uint8", "numpy.zeros", "numpy.empty" ] ]

mrdbarros/csgo_analyze

[ "a4d7487bd56a14a99dc762920965060a5a43fa15" ]

[ "models.py" ]

[ "import data_loading\nimport torch\n\n\n\n\n\ndef emb_sz_rule(n_cat):\n \"Rule of thumb to pick embedding size corresponding to `n_cat`\"\n return min(600, round(1.6 * n_cat ** 0.56))\n\n\nclass LinBnDrop(torch.nn.Sequential):\n \"Module grouping `BatchNorm1d`, `Dropout` and `Linear` layers\"\n\n def __init__(self, n_in, n_out, bn=True, p=0., act=None, lin_first=False):\n layers = [torch.nn.BatchNorm1d(n_in)] if bn else []\n if p != 0: layers.append(torch.nn.Dropout(p))\n lin = [torch.nn.Linear(n_in, n_out, bias=not bn)]\n if act is not None: lin.append(act)\n layers = lin + layers if lin_first else layers + lin\n super().__init__(*layers)\n\n\n\nclass TabularModelCustom(torch.nn.Module):\n \"Basic model for tabular data.\"\n\n def __init__(self, category_list, class_groups_sizes, n_cont, layers, ps=None, embed_p=0.,\n use_bn=True, bn_final=True, bn_cont=True):\n\n super().__init__()\n ps = ps\n\n class_group_map = {}\n for i, cat in enumerate(category_list):\n class_group = cat[cat.rfind(\"_\") + 1:]\n class_group_index, _ = class_groups_sizes[class_group]\n if class_group_index in class_group_map:\n class_group_map[class_group_index].append(i)\n else:\n class_group_map[class_group_index] = [i]\n self.class_group_map = class_group_map\n self.embeds = torch.nn.ModuleList(\n [torch.nn.Embedding(index_ni[1], emb_sz_rule(index_ni[1])) for _, index_ni in class_groups_sizes.items() if\n index_ni[1] > 2])\n self.emb_drop = torch.nn.Dropout(embed_p)\n self.bn_cont = torch.nn.BatchNorm1d(n_cont) if bn_cont else None\n\n binary_size = sum(len(class_group_map[i]) for i in range(len(self.embeds), len(class_group_map)))\n n_emb = sum(e.embedding_dim * len(class_group_map[i]) for i, e in enumerate(self.embeds)) + binary_size\n self.n_emb, self.n_cont = n_emb, n_cont\n sizes = [n_emb + n_cont] + layers\n actns = [torch.nn.ReLU(inplace=True) for _ in range(len(sizes) - 1)]\n _layers = [LinBnDrop(sizes[i], sizes[i + 1], bn=use_bn and (i != len(actns) - 1 or bn_final), p=p, act=a)\n for i, (p, a) in enumerate(zip(ps, actns))]\n\n self.layers = torch.nn.Sequential(*_layers)\n\n def forward(self, x_cat, x_cont=None):\n\n if self.n_emb != 0:\n x_cat_binary = []\n for i in range(len(self.embeds), len(self.class_group_map)):\n x_cat_binary += self.class_group_map[i]\n with torch.no_grad():\n x_cat_binary = x_cat[:, x_cat_binary].float()\n x_cat_nonbinary = [torch.flatten(e(x_cat[:, self.class_group_map[i]]), start_dim=1) for i, e in\n enumerate(self.embeds)]\n x = torch.cat(x_cat_nonbinary + [x_cat_binary], 1)\n x = self.emb_drop(x)\n if self.n_cont != 0:\n if self.bn_cont is not None: x_cont = self.bn_cont(x_cont)\n x = torch.cat([x, x_cont], 1) if self.n_emb != 0 else x_cont\n return self.layers(x)\n\n\n\nclass CustomMixedModel(torch.nn.Module):\n def __init__(self, image_model, tab_model, seq_model, image_output_size, embeds_size,prepare_and_pad,max_image_batch):\n super(CustomMixedModel, self).__init__()\n self.image_model = image_model\n # embedding types are primaries, secondaries, flashbangs and binaries\n # self.classifier = TabularModel_NoCat(emb_sizes,1536, 30,[400],ps=[0.1],use_bn=False)\n self.tab_model = tab_model\n # n_emb = sum(e.embedding_dim for e in self.embeds)\n self.seq_model = seq_model\n self.classifier = torch.nn.Sequential(LinBnDrop(200 + image_output_size\n + embeds_size\n , 1, act=None, p=0.))\n self.prepare_and_pad = prepare_and_pad\n self.max_image_batch = max_image_batch\n def forward(self, input_cat, input_cont, input_image, attention_mask, train_embeds=True, train_seq_model=True):\n valid_sizes = torch.sum((attention_mask == 1), dim=1)\n if train_embeds:\n input_embed = self.forward_embeds(input_cat, input_cont, input_image,valid_sizes)\n else:\n with torch.no_grad():\n\n input_embed = self.forward_embeds(input_cat, input_cont, input_image,valid_sizes)\n\n input_embed=self.prepare_and_pad(input_embed,valid_sizes)\n\n if train_seq_model:\n\n bert_out = self.forward_seq_model(input_embed, attention_mask)\n else:\n with torch.no_grad():\n bert_out = self.forward_seq_model(input_embed, attention_mask)\n\n\n\n output = self.classifier(\n torch.cat((input_embed[range(input_embed.shape[0]), valid_sizes-1], bert_out),\n dim=1))\n # output = self.classifier(input_embed[range(input_embed.shape[0]), (input_embed.shape[1] - mask_size - 1)])\n # output = self.classifier(bert_out)\n return output\n\n def forward_embeds(self, input_cat, input_cont, input_image,valid_size):\n n_batches = (input_image.shape[0]//self.max_image_batch)+1*(input_image.shape[0]%self.max_image_batch>0)\n\n tab_out = self.tab_model(input_cat,input_cont)\n image_out = torch.cat([self.image_model(input_image[i*self.max_image_batch:min((i+1)*self.max_image_batch,input_image.shape[0])])\n for i in range(n_batches)],dim=0)\n # comprehension to break inputs in 'n_batches' of 'self.max_image_batch' size\n input_embed = torch.cat((tab_out,image_out),dim=1)\n input_embed = torch.nn.ReLU()(input_embed)\n return input_embed\n\n def forward_seq_model(self, input_embed, attention_mask):\n # bert_out = self.seq_model(input_embed.permute((1, 0, 2)),\n # src_key_padding_mask=attention_mask).permute((1, 0, 2))[:, 0]\n bert_out = torch.mean(self.seq_model(inputs_embeds=input_embed,\n attention_mask=attention_mask)[0],dim=1)\n bert_out = torch.nn.ReLU()(bert_out)\n return bert_out\n\n\nclass CustomMixedModelSingleImage(torch.nn.Module):\n def __init__(self, image_model, tab_model, image_output_size,class_p):\n super(CustomMixedModelSingleImage, self).__init__()\n self.image_model = image_model\n # embedding types are primaries, secondaries, flashbangs and binaries\n # self.classifier = TabularModel_NoCat(emb_sizes,1536, 30,[400],ps=[0.1],use_bn=False)\n self.tab_model = tab_model\n # n_emb = sum(e.embedding_dim for e in self.embeds)\n self.classifier = torch.nn.Sequential(LinBnDrop(50 + image_output_size, 40, act=torch.nn.ReLU(), p=class_p),\n LinBnDrop(40, 1, act=None, p=class_p))\n\n def forward(self, input_cat, input_cont, input_image):\n output_tabular = self.tab_model(input_cat, input_cont)\n output_image = self.image_model(input_image)\n logits = self.classifier(torch.nn.ReLU()(torch.cat((output_tabular, output_image), dim=1)))\n\n return logits\n\n" ]

[ [ "torch.nn.Sequential", "torch.nn.Dropout", "torch.nn.BatchNorm1d", "torch.cat", "torch.sum", "torch.nn.Linear", "torch.no_grad", "torch.nn.ReLU" ] ]

tomiock/qGAN

[ "fb98a2b5286eb479665ade353efa40bd6e55dc36" ]

[ "quantumGAN/deprecated_files/discriminator_minimax.py" ]

[ "\"\"\"DISCRIMINATOR BCE\"\"\"\nimport json\nimport random\nfrom typing import Dict, List\n\nimport numpy as np\n\nfrom quantumGAN.functions import minimax_derivative_fake, minimax_derivative_real, sigmoid, \\\n\tsigmoid_prime\n\n\ndef load(filename):\n\tf = open(filename, \"r\")\n\tdata = json.load(f)\n\tf.close()\n\t# cost = getattr(sys.modules[__name__], data[\"cost\"])\n\tnet = ClassicalDiscriminatorMINIMAX(None, None, data[\"sizes\"], data[\"loss\"])\n\tnet.weights = [np.array(w) for w in data[\"weights\"]]\n\tnet.biases = [np.array(b) for b in data[\"biases\"]]\n\treturn net\n\n\nclass ClassicalDiscriminatorMINIMAX:\n\n\tdef __init__(self,\n\t training_data: List or None,\n\t mini_batch_size: int or None,\n\t sizes: List[int],\n\t loss_BCE: bool) -> None:\n\n\t\tself.training_data = training_data\n\t\tself.mini_batch_size: int = mini_batch_size\n\t\tself.num_layers = len(sizes)\n\t\tself.sizes = sizes\n\t\tself.loss_BCE = loss_BCE\n\t\tself.data_loss = {\"real\": [],\n\t\t \"fake\": []}\n\t\tself.ret: Dict[str, any] = {\"loss\": [],\n\t\t \"label real\": [],\n\t\t \"label fake\": [],\n\t\t \"label fake time\": [],\n\t\t \"label real time\": []}\n\t\tself.biases = [np.random.randn(y, ) for y in sizes[1:]]\n\t\tself.weights = [np.random.randn(y, x)\n\t\t for x, y in zip(sizes[:-1], sizes[1:])]\n\n\tdef feedforward(self, a):\n\t\t\"\"\"Return the output of the network if ``a`` is input.\"\"\"\n\t\tfor b, w in zip(self.biases, self.weights):\n\t\t\ta = sigmoid(np.dot(w, a) + b)\n\t\treturn a\n\n\tdef predict(self, x):\n\t\t# feedforward\n\t\tactivation = x\n\t\tzs = [] # list to store all the z vectors, layer by layer\n\t\tfor b, w in zip(self.biases, self.weights):\n\t\t\tz = np.dot(w, activation) + b\n\t\t\tzs.append(z)\n\t\t\tactivation = sigmoid(z)\n\t\treturn activation\n\n\tdef evaluate(self, test_data):\n\n\t\ttest_results = [(np.argmax(self.feedforward(x)), y)\n\t\t for (x, y) in test_data]\n\t\treturn sum(int(x == y) for (x, y) in test_results)\n\n\tdef save(self, filename):\n\t\t\"\"\"Save the neural network to the file ``filename``.\"\"\"\n\t\tdata = {\"sizes\": self.sizes,\n\t\t \"weights\": [w.tolist() for w in self.weights],\n\t\t \"biases\": [b.tolist() for b in self.biases],\n\t\t \"loss\": self.loss_BCE # ,\n\t\t # \"cost\": str(self..__name__)\n\t\t }\n\t\tf = open(filename, \"w\")\n\t\tjson.dump(data, f)\n\t\tf.close()\n\n\tdef forwardprop(self, x: np.ndarray):\n\t\tactivation = x\n\t\tactivations = [x] # list to store all the activations, layer by layer\n\t\tzs = [] # list to store all the z vectors, layer by layer\n\t\tfor b, w in zip(self.biases, self.weights):\n\t\t\tz = np.dot(w, activation) + b\n\t\t\tzs.append(z)\n\t\t\tactivation = sigmoid(z)\n\t\t\tactivations.append(activation)\n\t\treturn activation, activations, zs\n\n\tdef backprop(self, real_image, fake_image, is_real):\n\t\t\"\"\"Return a tuple ``(nabla_b, nabla_w)`` representing the\n gradient for the cost function C_x. ``nabla_b`` and\n ``nabla_w`` are layer-by-layer lists of numpy arrays, similar\n to ``self.biases`` and ``self.weights``.\"\"\"\n\t\tnabla_b = [np.zeros(b.shape) for b in self.biases]\n\t\tnabla_w = [np.zeros(w.shape) for w in self.weights]\n\n\t\t# feedforward and back error calculation depending on type of image\n\t\tactivation_real, activations_real, zs_real = self.forwardprop(real_image)\n\t\tactivation_fake, activations_fake, zs_fake = self.forwardprop(fake_image)\n\n\t\tif is_real:\n\t\t\tdelta = minimax_derivative_real(activations_real[-1]) * sigmoid_prime(zs_real[-1])\n\t\t\tactivations, zs = activations_real, zs_real\n\t\telse:\n\t\t\tdelta = minimax_derivative_fake(activations_fake[-1]) * sigmoid_prime(zs_fake[-1])\n\t\t\tactivations, zs = activations_fake, zs_fake\n\n\t\t# backward pass\n\t\tnabla_b[-1] = delta\n\t\tnabla_w[-1] = np.dot(delta, activations[-2].reshape(1, activations[-2].shape[0]))\n\n\t\tfor l in range(2, self.num_layers):\n\t\t\tz = zs[-l]\n\t\t\tdelta = np.dot(self.weights[-l + 1].transpose(), delta) * sigmoid_prime(z)\n\t\t\tnabla_b[-l] = delta\n\t\t\tnabla_w[-l] = np.dot(delta.reshape(delta.shape[0], 1),\n\t\t\t activations[-l - 1].reshape(1, activations[-l - 1].shape[0]))\n\t\treturn nabla_b, nabla_w, activations[-1]\n\n\tdef train_mini_batch(self, mini_batch, learning_rate):\n\t\tglobal label_real, label_fake\n\t\tnabla_b = [np.zeros(b.shape) for b in self.biases]\n\t\tnabla_w = [np.zeros(w.shape) for w in self.weights]\n\n\t\tfor real_image, fake_image in mini_batch:\n\t\t\tdelta_nabla_b, delta_nabla_w, label_real = self.backprop(real_image, fake_image, True)\n\t\t\tnabla_b = [nb + dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]\n\t\t\tnabla_w = [nw + dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]\n\n\t\t\tdelta_nabla_b, delta_nabla_w, label_fake = self.backprop(real_image, fake_image, False)\n\t\t\tnabla_b = [nb + dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]\n\t\t\tnabla_w = [nw + dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]\n\n\t\t# gradient descent\n\t\t# nabla_w and nabla_b are multiplied by the learning rate\n\t\t# and taken the mean of (dividing by the mini batch size)\n\t\tself.weights = [w - (learning_rate / len(mini_batch)) * nw\n\t\t for w, nw in zip(self.weights, nabla_w)]\n\t\tself.biases = [b - (learning_rate / len(mini_batch)) * nb\n\t\t for b, nb in zip(self.biases, nabla_b)]\n\n\tdef create_mini_batches(self):\n\t\tn = len(self.training_data)\n\t\trandom.shuffle(self.training_data)\n\t\tmini_batches = [\n\t\t\tself.training_data[k:k + self.mini_batch_size]\n\t\t\tfor k in range(0, n, self.mini_batch_size)]\n\t\treturn [mini_batches[0]]\n" ]

[ [ "numpy.dot", "numpy.array", "numpy.random.randn", "numpy.zeros" ] ]

litosly/RankingOptimizationApprochtoLLC

[ "b6b79fb1364fcc481aa84093a8e8399966b19d02" ]

[ "models/llc_score.py" ]

[ "from prediction.predictor import predict_scores, predict_vector\nfrom sklearn.linear_model import LinearRegression\nfrom utils.critique import LP1SimplifiedOptimize\nfrom utils.keyphrase_selection import *\n\nimport numpy as np\nfrom tqdm import tqdm\n\n\nclass LP1Simplified(object):\n def __init__(self, keyphrase_freq, item_keyphrase_freq, row, matrix_Train, matrix_Test, test_users,\n target_ranks, num_items_sampled, num_keyphrases, df,\n max_iteration_threshold, keyphrase_popularity, dataset_name,\n model, parameters_row, keyphrase_selection_method, topk=None, lamb = None,**unused):\n self.keyphrase_freq = keyphrase_freq\n self.item_keyphrase_freq = item_keyphrase_freq.T\n self.row = row\n self.matrix_Train = matrix_Train\n self.num_users, self.num_items = matrix_Train.shape\n self.matrix_Test = matrix_Test\n self.test_users = test_users\n self.target_ranks = target_ranks\n self.num_items_sampled = num_items_sampled\n self.num_keyphrases = num_keyphrases\n self.df = df\n self.max_iteration_threshold = max_iteration_threshold\n self.keyphrase_popularity = keyphrase_popularity\n self.dataset_name = dataset_name\n self.model = model\n self.parameters_row = parameters_row\n\n self.keyphrase_selection_method = keyphrase_selection_method\n self.max_wanted_keyphrase = max_iteration_threshold # Set diff length to be equal to max_iteration_threshold\n self.topk = topk\n def start_critiquing(self):\n self.get_initial_predictions()\n for user in tqdm(self.test_users):\n # User id starts from 0\n self.row['user_id'] = user\n\n # The iteration will stop if the wanted item is in top n\n for target_rank in self.target_ranks:\n self.row['target_rank'] = target_rank\n # Pick wanted items in test items\n candidate_items = self.matrix_Test[user].nonzero()[1]\n train_items = self.matrix_Train[user].nonzero()[1]\n wanted_items = np.setdiff1d(candidate_items, train_items)\n\n for item in wanted_items:\n # Item id starts from 0\n self.row['item_id'] = item\n # Set the wanted item's initial rank as None\n self.row['item_rank'] = None\n # Set the wanted item's initial prediction score as None\n self.row['item_score'] = None\n\n # Get the item's existing keyphrases\n item_keyphrases = self.item_keyphrase_freq[item].nonzero()[0]\n # Get keyphrases that don't belong to the item (we can critique)\n remaining_keyphrases = np.setdiff1d(range(self.num_keyphrases), item_keyphrases)\n# print(\"The number of remaining_keyphrases is {}. remaining_keyphrases are: {}\".format(len(remaining_keyphrases), remaining_keyphrases))\n self.row['num_existing_keyphrases'] = len(remaining_keyphrases)\n\n if self.keyphrase_selection_method == \"diff\":\n # For keyphrase selection method 'diff' \n target_keyphrase_freq = get_item_keyphrase_freq(self.item_keyphrase_freq,item = item)\n # diff_keyphrase_freq = top_recommended_keyphrase_freq - target_keyphrase_freq\n # remaining_keyphrases = np.argsort(np.ravel(diff_keyphrase_freq))[::-1][:self.max_wanted_keyphrase]\n self.row['num_existing_keyphrases'] = self.max_iteration_threshold\n\n\n if len(remaining_keyphrases) == 0:\n break\n self.row['iteration'] = 0\n self.row['critiqued_keyphrase'] = None\n self.row['result'] = None\n self.df = self.df.append(self.row, ignore_index=True)\n\n query = []\n affected_items = np.array([])\n\n\n for iteration in range(self.max_iteration_threshold):\n self.row['iteration'] = iteration + 1\n\n if self.keyphrase_selection_method == \"pop\":\n # Always critique the most popular keyphrase\n critiqued_keyphrase = remaining_keyphrases[np.argmax(self.keyphrase_popularity[remaining_keyphrases])]\n elif self.keyphrase_selection_method == \"random\":\n # Randomly critique a remaining keyphrase\n critiqued_keyphrase = np.random.choice(remaining_keyphrases, size=1, replace=False)[0]\n elif self.keyphrase_selection_method == \"diff\":\n if iteration == 0:\n initial_prediction_items = predict_vector(rating_vector=self.prediction_scores[user],\n train_vector=self.matrix_Train[user],\n remove_train=True)\n top_recommended_keyphrase_freq = get_item_keyphrase_freq(self.item_keyphrase_freq,item = initial_prediction_items[0])\n self.row[\"Recommended Item\"] = initial_prediction_items[0]\n # self.row['Recommended Item Name'] = get_restaurant_name(self.df_train, self.business_df,initial_prediction_items[0])\n else:\n top_recommended_keyphrase_freq = get_item_keyphrase_freq(self.item_keyphrase_freq,item = prediction_items[0])\n self.row[\"Recommended Item\"] = prediction_items[0]\n # self.row['Recommended Item Name'] = get_restaurant_name(self.df_train, self.business_df,prediction_items[0])\n diff_keyphrase_freq = top_recommended_keyphrase_freq - target_keyphrase_freq\n remaining_keyphrases = np.argsort(np.ravel(diff_keyphrase_freq))[::-1][:self.max_wanted_keyphrase]\n critiqued_keyphrase = remaining_keyphrases[0]\n\n self.row['critiqued_keyphrase'] = critiqued_keyphrase\n query.append(critiqued_keyphrase)\n\n # Get affected items (items have critiqued keyphrase)\n current_affected_items = self.item_keyphrase_freq[:, critiqued_keyphrase].nonzero()[0]\n affected_items = np.unique(np.concatenate((affected_items, current_affected_items))).astype(int)\n unaffected_items = np.setdiff1d(range(self.num_items), affected_items)\n\n if iteration == 0:\n prediction_items = predict_vector(rating_vector=self.prediction_scores[user],\n train_vector=self.matrix_Train[user],\n remove_train=True)\n\n affected_items_mask = np.in1d(prediction_items, affected_items)\n affected_items_index_rank = np.where(affected_items_mask == True)\n unaffected_items_index_rank = np.where(affected_items_mask == False)\n\n import copy\n top_k = int(self.topk)\n prediction_scores_u, lambdas = LP1SimplifiedOptimize(initial_prediction_u=self.prediction_scores[user],\n keyphrase_freq=copy.deepcopy(self.keyphrase_freq),\n affected_items=np.intersect1d(affected_items, prediction_items[affected_items_index_rank[0][:top_k]]),\n unaffected_items=np.intersect1d(unaffected_items, prediction_items[unaffected_items_index_rank[0][:top_k]]),\n num_keyphrases=self.num_keyphrases,\n query=query,\n test_user=user,\n item_latent=self.Y,\n reg=self.reg)\n\n self.row['lambda'] = lambdas\n prediction_items = predict_vector(rating_vector=prediction_scores_u,\n train_vector=self.matrix_Train[user],\n remove_train=True)\n recommended_items = prediction_items\n\n # Current item rank\n item_rank = np.where(recommended_items == item)[0][0]\n\n self.row['item_rank'] = item_rank\n self.row['item_score'] = prediction_scores_u[item]\n\n if item_rank + 1 <= target_rank:\n # Items is ranked within target rank\n self.row['result'] = 'successful'\n self.df = self.df.append(self.row, ignore_index=True)\n break\n else:\n remaining_keyphrases = np.setdiff1d(remaining_keyphrases, critiqued_keyphrase)\n # Continue if more keyphrases and iterations remained\n if len(remaining_keyphrases) > 0 and self.row['iteration'] < self.max_iteration_threshold:\n self.row['result'] = None\n self.df = self.df.append(self.row, ignore_index=True)\n else:\n # Otherwise, mark fail\n self.row['result'] = 'fail'\n self.df = self.df.append(self.row, ignore_index=True)\n break\n return self.df\n\n\n def get_initial_predictions(self):\n self.RQ, Yt, Bias = self.model(self.matrix_Train,\n iteration=self.parameters_row['iter'].values[0],\n lamb=self.parameters_row['lambda'].values[0],\n rank=self.parameters_row['rank'].values[0])\n self.Y = Yt.T\n\n self.reg = LinearRegression().fit(self.keyphrase_freq, self.RQ)\n\n self.prediction_scores = predict_scores(matrix_U=self.RQ,\n matrix_V=self.Y,\n bias=Bias)\n\n" ]

[ [ "numpy.random.choice", "numpy.in1d", "numpy.setdiff1d", "numpy.concatenate", "numpy.intersect1d", "numpy.argmax", "sklearn.linear_model.LinearRegression", "numpy.ravel", "numpy.array", "numpy.where" ] ]

MiningMyBusiness/SketchyExperiments

[ "11f3baee63a984501b9707aa58420540b19db59f" ]

[ "Autoencoding/save32by32ForAll.py" ]

[ "## Name: Save 32 by 32 image vector\r\n## Description: Reads in the matrix representation of the images\r\n## for each class and resizes each image from 256 by 256\r\n## to 32 by 32 and then converts it to a vector with\r\n## 1024 elements (32*32). A stack of these vectors (matrix)\r\n## is then saved in the class directory.\r\n## NOTE: This code uses the output from PNGtoNumpy.py\r\n## Author: Kiran Bhattacharyya\r\n\r\nimport glob\r\nimport numpy as np\r\nimport matplotlib.pyplot as plt\r\nimport cv2\r\n\r\n# location of the data\r\ndataLoc = '256X256/sketch/tx_000100000000'\r\n\r\nallFolders = glob.glob(dataLoc + '/*') # get all folders with data\r\n\r\nnewSize = 32\r\n\r\ndef readImgAndResize(folderName, multi, newSize):\r\n imgStack_mat = np.load(folder + '/matStack.npy')\r\n num_of_images = imgStack_mat.shape[2]\r\n smallerImgs = np.zeros((num_of_images, newSize**2))\r\n for i in range(0, int(multi*num_of_images)):\r\n smallerImgs[i, :] = resizeAndVectorize(imgStack_mat[:, :, i], newSize)\r\n return smallerImgs\r\n\r\ndef resizeAndVectorize(thisImg, newSize):\r\n resized = cv2.resize(thisImg, (newSize, newSize),\r\n interpolation=cv2.INTER_AREA)\r\n resized = np.reshape(resized, newSize**2)\r\n resized = resized - np.min(resized)\r\n resized = resized/np.max(resized)\r\n return resized\r\n\r\n\r\nfolderCount = 0\r\niter = 0\r\nmulti = 1.0\r\nallData = []\r\nfor folder in allFolders:\r\n print('Folder ' + str(folderCount+1) + ' of ' + str(len(allFolders)) + '.')\r\n smallerImgs = readImgAndResize(folder, multi, newSize)\r\n np.save(folder + '/32by32vecStack.npy', smallerImgs)\r\n folderCount += 1\r\n" ]

[ [ "numpy.min", "numpy.reshape", "numpy.save", "numpy.max", "numpy.load", "numpy.zeros" ] ]

mwanakijiji/rrlfe2

[ "4a822bb499bd0af4543f8b34d9322e812a5a3d2c" ]

[ "tests/test_scrape_ew_and_errew.py" ]

[ "import matplotlib\nmatplotlib.use('Agg')\n\nimport sys, os\nfrom configparser import ConfigParser, ExtendedInterpolation\nimport pandas as pd\nimport astropy\n\ncurrent_dir = os.path.dirname(__file__)\ntarget_dir = os.path.abspath(os.path.join(current_dir, \"../\"))\nsys.path.insert(0, target_dir)\n\n# import more things with changed system path\nfrom modules import *\nfrom modules import scrape_ew_and_errew\nfrom conf import *\nimport numpy as np\nimport glob\n\n# configuration data for reduction\nconfig_red = ConfigParser(interpolation=ExtendedInterpolation()) # for parsing values in .init file\n# config for reduction to find a, b, c, d\nconfig_red.read(os.path.join(os.path.dirname(__file__), '../conf', 'config_red.ini'))\n\n\ndef test_line_order_check():\n\n dummy_lines = [3933.660,3970.075,4101.7100,4340.472,4861.290]\n test_num_glitches_0 = scrape_ew_and_errew.line_order_check(dummy_lines)\n dummy_lines[1] = 3990.\n dummy_lines[3] = 4320.\n test_num_glitches_1 = scrape_ew_and_errew.line_order_check(dummy_lines)\n dummy_lines[0] = 3913.\n dummy_lines[2] = 4121.\n dummy_lines[4] = 4881.\n test_num_glitches_2 = scrape_ew_and_errew.line_order_check(dummy_lines)\n\n # assert glitches is boolean\n assert test_num_glitches_0 == 0\n assert test_num_glitches_1 == 1\n assert test_num_glitches_2 == 1\n\n\ndef test_Scraper():\n\n '''\n write_dir_test = config_red[\"data_dirs\"][\"TEST_DIR_BIN\"]\n robo_dir = config_red[\"sys_dirs\"][\"DIR_ROBO\"]\n file_names_test = glob.glob(config_red[\"data_dirs\"][\"TEST_DIR_SRC\"] + \"spec_norm_final/*\")\n '''\n\n # instantiate\n scraper_instance = scrape_ew_and_errew.Scraper(subdir = config_red[\"data_dirs\"][\"TEST_DIR_ROBO_OUTPUT\"],\n file_scraped_info = config_red[\"data_dirs\"][\"TEST_DIR_BIN\"]+\"scraper_output/\"+config_red[\"file_names\"][\"SCRAPED_EW_ALL_DATA\"])\n\n\n # try a single instance; does it work?\n # note the writing of files is not directly tested here\n function_state = True\n try:\n test = scraper_instance()\n except Exception as e:\n # e contains printable attributes of exception object\n function_state = False\n\n # assert that instantiation worked\n assert function_state\n\n # make sure lines are really being identified correctly\n assert np.allclose(test.where(test[\"line_name\"]==\"CaIIK\").dropna()[\"wavel_found_center\"],3933.660, atol=2.)\n assert np.allclose(test.where(test[\"line_name\"]==\"Heps\").dropna()[\"wavel_found_center\"],3970.075, atol=2.)\n assert np.allclose(test.where(test[\"line_name\"]==\"Hdel\").dropna()[\"wavel_found_center\"],4101.710, atol=2.)\n assert np.allclose(test.where(test[\"line_name\"]==\"Hgam\").dropna()[\"wavel_found_center\"],4340.472, atol=2.)\n assert np.allclose(test.where(test[\"line_name\"]==\"Hbet\").dropna()[\"wavel_found_center\"],4861.290, atol=2.)\n\n # only 2 of the 3 spectra should have been scraped, because one should have\n # triggered a parsing errors\n assert len(test.where(test[\"line_name\"]==\"CaIIK\").dropna()) == 2\n\n\n\ndef test_quality_check():\n\n data_out_test = scrape_ew_and_errew.quality_check(\n read_in_filename = config_red[\"data_dirs\"][\"TEST_DIR_BIN\"]+\"scraper_output/\"+config_red[\"file_names\"][\"TEST_SCRAPED_EW_ALL_DATA\"],\n write_out_filename = config_red[\"data_dirs\"][\"TEST_DIR_BIN\"]+\"scraper_output/\"+config_red[\"file_names\"][\"TEST_SCRAPED_EW_DATA_GOOD_ONLY\"])\n\n # lots of checks of data types\n # note this uses .iloc[0] instead of [0], because bad rows with index 0 may\n # have been removed\n assert isinstance(data_out_test[\"wavel_stated_center\"].iloc[0],np.float64)\n assert isinstance(data_out_test[\"wavel_found_center\"].iloc[0],np.float64)\n assert isinstance(data_out_test[\"gaussianSigma\"].iloc[0],np.float64)\n assert isinstance(data_out_test[\"gaussianAmp\"].iloc[0],np.float64)\n assert isinstance(data_out_test[\"uncertaintyMu\"].iloc[0],np.float64)\n assert isinstance(data_out_test[\"uncertaintySigma\"].iloc[0],np.float64)\n assert isinstance(data_out_test[\"uncertaintyAmp\"].iloc[0],np.float64)\n assert isinstance(data_out_test[\"priorMu\"].iloc[0],np.float64)\n assert isinstance(data_out_test[\"priorSigma\"].iloc[0],np.float64)\n assert isinstance(data_out_test[\"priorAmp\"].iloc[0],np.float64)\n assert isinstance(data_out_test[\"EQW\"].iloc[0],np.float64)\n assert isinstance(data_out_test[\"uncertaintyEQW\"].iloc[0],np.float64)\n assert isinstance(data_out_test[\"chiSqr\"].iloc[0],np.float64)\n assert isinstance(data_out_test[\"flags\"].iloc[0],str)\n assert isinstance(data_out_test[\"blendGroup\"].iloc[0],np.int64)\n assert isinstance(data_out_test[\"line_name\"].iloc[0],str)\n assert isinstance(data_out_test[\"robolines_file_name\"].iloc[0],str)\n assert isinstance(data_out_test[\"realization_spec_file_name\"].iloc[0],str)\n assert isinstance(data_out_test[\"quality\"].iloc[0],str)\n\ndef test_stack_spectra():\n\n print(\"input list\")\n print(config_red[\"data_dirs\"][\"TEST_DIR_SRC\"] + \"test_input_file_list.list\")\n print(\"read in file name\")\n\n data_stacked_test = scrape_ew_and_errew.stack_spectra(\n read_in_filename = config_red[\"data_dirs\"][\"TEST_DIR_BIN\"]+\"scraper_output/\"+config_red[\"file_names\"][\"TEST_SCRAPED_EW_DATA_GOOD_ONLY\"],\n write_out_filename = config_red[\"data_dirs\"][\"TEST_DIR_BIN\"]+\"scraper_output/\"+config_red[\"file_names\"][\"TEST_RESTACKED_EW_DATA_GOOD_ONLY\"],\n input_list = config_red[\"data_dirs\"][\"TEST_DIR_SRC\"] + \"test_input_file_list.list\")\n\n print(\"data_stacked\")\n print(data_stacked_test.keys())\n\n # lots of checks of data types\n # note this uses .iloc[0] instead of [0], because bad rows with index 0 may\n # have been removed\n\n assert isinstance(data_stacked_test[\"realization_spec_file_name\"].iloc[0],str)\n assert isinstance(data_stacked_test[\"orig_spec_file_name\"].iloc[0],str)\n assert isinstance(data_stacked_test[\"EW_Hbeta\"].iloc[0],np.float64)\n assert isinstance(data_stacked_test[\"err_EW_Hbeta_from_robo\"].iloc[0],np.float64)\n assert isinstance(data_stacked_test[\"EW_Hdelta\"].iloc[0],np.float64)\n assert isinstance(data_stacked_test[\"err_EW_Hdelta_from_robo\"].iloc[0],np.float64)\n assert isinstance(data_stacked_test[\"EW_Hgamma\"].iloc[0],np.float64)\n assert isinstance(data_stacked_test[\"err_EW_Hgamma_from_robo\"].iloc[0],np.float64)\n assert isinstance(data_stacked_test[\"EW_Heps\"].iloc[0],np.float64)\n assert isinstance(data_stacked_test[\"err_EW_Heps_from_robo\"].iloc[0],np.float64)\n assert isinstance(data_stacked_test[\"EW_CaIIK\"].iloc[0],np.float64)\n assert isinstance(data_stacked_test[\"err_EW_CaIIK_from_robo\"].iloc[0],np.float64)\n\n\ndef test_generate_net_balmer():\n ## ## CONTINUE HERE; FINISH THIS TEST\n\n # generate the fake data: H_del =\n\n params_data, data_net_balmer_test = scrape_ew_and_errew.generate_net_balmer(\n read_in_filename = config_red[\"data_dirs\"][\"TEST_DIR_BIN\"]+\"scraper_output/test_stacked_data_pre_net_balmer_calc.csv\",\n write_out_filename = config_red[\"data_dirs\"][\"TEST_DIR_BIN\"]+\"scraper_output/test_stacked_data_post_net_balmer_calc.csv\")\n\n # is the Balmer line a true element wise average?\n\n #assert np.array(data_net_balmer_test[\"EW_Balmer\"]) == np.mean([data_net_balmer_test[\"EW_Hgamma\"],data_net_balmer_test[\"EW_Hdelta\"]], axis=0)\n '''\n # check data type of newly-added data\n assert isinstance(data_net_balmer_test[\"EW_Balmer\"].iloc[0],np.float64)\n assert isinstance(data_net_balmer_test[\"err_EW_Balmer_based_Robo\"].iloc[0],np.float64)\n '''\n assert 1<2\n\n\ndef test_generate_addl_ew_errors():\n # placeholder for now, until more decisions about how to calculate EW errors\n\n test_df_postbalmer_errors = scrape_ew_and_errew.generate_addl_ew_errors(read_in_filename=config_red[\"data_dirs\"][\"TEST_DIR_SRC\"]+config_red[\"file_names\"][\"TEST_RESTACKED_EW_DATA_W_NET_BALMER\"],\n write_out_filename=config_red[\"data_dirs\"][\"TEST_DIR_BIN\"]+config_red[\"file_names\"][\"TEST_RESTACKED_EW_DATA_W_NET_BALMER_ERRORS\"])\n\n # loop through batches of rows corresponding to an individual spectrum, and\n # make sure the errors are consistent and the value expected\n array_1 = test_df_postbalmer_errors[\"err_EW_Balmer_based_noise_churning\"].where(test_df_postbalmer_errors[\"orig_spec_file_name\"]==\"575020m10.smo\").dropna().values\n array_2 = test_df_postbalmer_errors[\"err_EW_Balmer_based_noise_churning\"].where(test_df_postbalmer_errors[\"orig_spec_file_name\"]==\"575020m15.smo\").dropna().values\n array_3 = test_df_postbalmer_errors[\"err_EW_Balmer_based_noise_churning\"].where(test_df_postbalmer_errors[\"orig_spec_file_name\"]==\"575020m20.smo\").dropna().values\n # check that error values are same\n assert np.all(array_1)\n assert np.all(array_2)\n assert np.all(array_3)\n # check that one value has expected value\n assert round(array_1[0], 3) == 0.023\n assert round(array_2[0], 3) == 0.020\n assert round(array_3[0], 3) == 0.048\n\n # in unusual case where collapsing the noise-churned spectra is not desired\n test_df_postbalmer_errors_nogrouping = scrape_ew_and_errew.generate_addl_ew_errors(read_in_filename=config_red[\"data_dirs\"][\"TEST_DIR_SRC\"]+config_red[\"file_names\"][\"TEST_RESTACKED_EW_DATA_W_NET_BALMER\"],\n write_out_filename=config_red[\"data_dirs\"][\"TEST_DIR_BIN\"]+config_red[\"file_names\"][\"TEST_RESTACKED_EW_DATA_W_NET_BALMER_ERRORS\"],\n groupby_parent = False)\n\n array_1_children = test_df_postbalmer_errors_nogrouping.where(test_df_postbalmer_errors[\"orig_spec_file_name\"]==\"575020m10.smo\").dropna()\n\n # there are 40 rows for each parent spectrum, and the Balmer EW values are different in each\n assert len(array_1_children) == 20\n assert np.std(array_1_children[\"EW_Balmer\"]) > 0\n\n\ndef test_add_synthetic_meta_data():\n\n combined_data = scrape_ew_and_errew.add_synthetic_meta_data(input_list = config_red[\"data_dirs\"][\"TEST_DIR_SRC\"] + config_red[\"file_names\"][\"TEST_LIST_SPEC_PHASE\"],\n read_in_filename = config_red[\"data_dirs\"][\"TEST_DIR_EW_PRODS\"]+config_red[\"file_names\"][\"TEST_RESTACKED_EW_DATA_W_NET_BALMER_ERRORS\"],\n write_out_filename = config_red[\"data_dirs\"][\"TEST_DIR_EW_PRODS\"]+config_red[\"file_names\"][\"TEST_RESTACKED_EW_DATA_W_METADATA_WRITEOUT\"])\n\n # columns from Robospect output and meta-data are all there\n assert \"wavel_stated_center\" in combined_data.columns\n assert \"feh\" in combined_data.columns\n assert \"teff\" in combined_data.columns\n # there are no nans in the table\n assert np.sum(combined_data.isnull().sum()) == 0\n" ]

[ [ "numpy.all", "matplotlib.use", "numpy.std" ] ]

CloudRenderVR/human-motion-prediction-pytorch-uncertainty

[ "cb96f3b2d8a2b54916b2f3f76c1c9b982af5b46b" ]

[ "src/translate.py" ]

[ "\n\"\"\"Simple code for training an RNN for motion prediction.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport math\nimport os\nimport random\nimport sys\nimport time\nimport h5py\n\nimport numpy as np\nfrom six.moves import xrange # pylint: disable=redefined-builtin\n\nimport data_utils\nimport seq2seq_model\nimport torch\nimport torch.optim as optim\nfrom torch.autograd import Variable\nimport argparse\n\n# Learning\nparser = argparse.ArgumentParser(description='Train RNN for human pose estimation')\nparser.add_argument('--learning_rate', dest='learning_rate',\n help='Learning rate',\n default=0.005, type=float)\nparser.add_argument('--learning_rate_decay_factor', dest='learning_rate_decay_factor',\n help='Learning rate is multiplied by this much. 1 means no decay.',\n default=0.95, type=float)\nparser.add_argument('--learning_rate_step', dest='learning_rate_step',\n help='Every this many steps, do decay.',\n default=10000, type=int)\nparser.add_argument('--batch_size', dest='batch_size',\n help='Batch size to use during training.',\n default=16, type=int)\nparser.add_argument('--max_gradient_norm', dest='max_gradient_norm',\n help='Clip gradients to this norm.',\n default=5, type=float)\nparser.add_argument('--iterations', dest='iterations',\n help='Iterations to train for.',\n default=1e5, type=int)\nparser.add_argument('--test_every', dest='test_every',\n help='',\n default=1000, type=int)\n# Architecture\nparser.add_argument('--architecture', dest='architecture',\n help='Seq2seq architecture to use: [basic, tied].',\n default='tied', type=str)\nparser.add_argument('--loss_to_use', dest='loss_to_use',\n help='The type of loss to use, supervised or sampling_based',\n default='sampling_based', type=str)\nparser.add_argument('--residual_velocities', dest='residual_velocities',\n help='Add a residual connection that effectively models velocities',action='store_true',\n default=False)\nparser.add_argument('--size', dest='size',\n help='Size of each model layer.',\n default=1024, type=int)\nparser.add_argument('--num_layers', dest='num_layers',\n help='Number of layers in the model.',\n default=1, type=int)\nparser.add_argument('--seq_length_in', dest='seq_length_in',\n help='Number of frames to feed into the encoder. 25 fp',\n default=50, type=int)\nparser.add_argument('--seq_length_out', dest='seq_length_out',\n help='Number of frames that the decoder has to predict. 25fps',\n default=10, type=int)\nparser.add_argument('--omit_one_hot', dest='omit_one_hot',\n help='', action='store_true',\n default=False)\nparser.add_argument('--taylor', dest='finite_taylor_extrapolate',\n help='Whether to augment the network with a taylor series extrapolation from a finite difference scheme of the previous frames', action='store_true',\n default=False)\n# Directories\nparser.add_argument('--data_dir', dest='data_dir',\n help='Data directory',\n default=os.path.normpath(\"./data/h3.6m/dataset\"), type=str)\nparser.add_argument('--train_dir', dest='train_dir',\n help='Training directory',\n default=os.path.normpath(\"./experiments/\"), type=str)\nparser.add_argument('--action', dest='action',\n help='The action to train on. all means all the actions, all_periodic means walking, eating and smoking',\n default='all', type=str)\nparser.add_argument('--use_cpu', dest='use_cpu',\n help='', action='store_true',\n default=False)\nparser.add_argument('--load', dest='load',\n help='Try to load a previous checkpoint.',\n default=0, type=int)\nparser.add_argument('--sample', dest='sample',\n help='Set to True for sampling.', action='store_true',\n default=False)\nparser.add_argument('--distribution_output_direct', dest='distribution_output_direct',\n default=False)\n\nargs = parser.parse_args()\n\ntrain_dir = os.path.normpath(os.path.join( args.train_dir, args.action,\n 'out_{0}'.format(args.seq_length_out),\n 'iterations_{0}'.format(args.iterations),\n args.architecture,\n args.loss_to_use,\n 'omit_one_hot' if args.omit_one_hot else 'one_hot',\n 'depth_{0}'.format(args.num_layers),\n 'size_{0}'.format(args.size),\n 'lr_{0}'.format(args.learning_rate),\n 'residual_vel' if args.residual_velocities else 'not_residual_vel'))\n\nprint(train_dir)\nos.makedirs(train_dir, exist_ok=True)\n\ndef create_model(actions, sampling=False):\n \"\"\"Create translation model and initialize or load parameters in session.\"\"\"\n model = seq2seq_model.Seq2SeqModel(\n args.architecture,\n args.seq_length_in if not sampling else 50,\n args.seq_length_out if not sampling else 100,\n args.size, # hidden layer size\n args.num_layers,\n args.max_gradient_norm,\n args.batch_size,\n args.learning_rate,\n args.learning_rate_decay_factor,\n args.loss_to_use if not sampling else \"sampling_based\",\n len( actions ),\n not args.omit_one_hot,\n args.residual_velocities,\n args.finite_taylor_extrapolate,\n output_as_normal_distribution = args.distribution_output_direct,\n dtype=torch.float32)\n\n if args.load <= 0:\n return model\n\n print(\"Loading model\")\n model = torch.load(train_dir + '/model_' + str(args.load))\n if sampling:\n model.source_seq_len = 50\n model.target_seq_len = 100\n return model\n\ndef clean_batch(batch):\n encoder_inputs, decoder_inputs, decoder_outputs = batch\n encoder_inputs = torch.from_numpy(encoder_inputs).float()\n decoder_inputs = torch.from_numpy(decoder_inputs).float()\n decoder_outputs = torch.from_numpy(decoder_outputs).float()\n if not args.use_cpu:\n encoder_inputs = encoder_inputs.cuda()\n decoder_inputs = decoder_inputs.cuda()\n decoder_outputs = decoder_outputs.cuda()\n encoder_inputs = Variable(encoder_inputs)\n decoder_inputs = Variable(decoder_inputs)\n decoder_outputs = Variable(decoder_outputs)\n return (encoder_inputs, decoder_inputs, decoder_outputs)\n\n\nimport flags\ndef get_loss(output, truth):\n if flags.translate_loss_func == \"mse\":\n return ( (output-truth)**2 ).mean()\n if flags.translate_loss_func == \"me\":\n return ( np.abs(output-truth) ).mean()\n if flags.translate_loss_func == \"mle\":\n assert(output.shape[-1] == truth.shape[-1] * 2)\n means = output[..., :int(truth.shape[-1])]\n sigmas = output[..., int(truth.shape[-1]):]\n #print(\"################################\")\n neg_log_likelihood = torch.sum(torch.log(torch.pow(sigmas, 2))) / 2.0\n\n p1 = (means - truth)\n p2 = p1 / sigmas\n p3 = torch.pow(p2, 2)\n #print(\"Sigma likelihood cont:\", neg_log_likelihood)\n neg_log_likelihood += torch.numel(means) / 2.0 * np.log(2.0*3.1415926)\n neg_log_likelihood += torch.sum(p3) / 2.0\n #print(\"Max Means:\", torch.max(means))\n #print(\"Min Sigmas:\", torch.min(sigmas))\n #print(\"p1 max:\", torch.max(torch.abs(p1)))\n #print(\"p1 avg:\", torch.mean(torch.abs(p1)))\n #print(\"p2 max:\", torch.max(torch.abs(p2)))\n #print(\"p3 max:\", torch.max(p3))\n #print(\"p3 min:\", torch.min(p3))\n #print(\"p3 avg:\", torch.mean(p3))\n #print(\"likelihood:\", neg_log_likelihood)\n return neg_log_likelihood\n\ndef train():\n \"\"\"Train a seq2seq model on human motion\"\"\"\n\n actions = define_actions( args.action )\n\n number_of_actions = len( actions )\n\n #these will all be expangles\n train_set, test_set, data_mean, data_std, dim_to_ignore, dim_to_use = read_all_data(\n actions, args.seq_length_in, args.seq_length_out, args.data_dir, not args.omit_one_hot )\n\n # Limit TF to take a fraction of the GPU memory\n\n if True:\n model = create_model(actions, args.sample)\n if not args.use_cpu:\n model = model.cuda()\n\n # === Read and denormalize the gt with srnn's seeds, as we'll need them\n # many times for evaluation in Euler Angles ===\n srnn_gts_euler = get_srnn_gts( actions, model, test_set, data_mean,\n data_std, dim_to_ignore, not args.omit_one_hot )\n\n #=== This is the training loop ===\n step_time, loss, val_loss = 0.0, 0.0, 0.0\n current_step = 0 if args.load <= 0 else args.load + 1\n previous_losses = []\n\n step_time, loss = 0, 0\n optimiser = optim.SGD(model.parameters(), lr=args.learning_rate)\n #optimiser = optim.Adam(model.parameters(), lr=learning_rate, betas = (0.9, 0.999))\n\n for _ in range( args.iterations ):\n optimiser.zero_grad()\n model.train()\n\n start_time = time.time()\n\n # Actual training\n\n # === Training step ===\n encoder_inputs, decoder_inputs, decoder_outputs = clean_batch(model.get_batch( train_set, not args.omit_one_hot ))\n preds = model(encoder_inputs, decoder_inputs)\n step_loss = get_loss(preds, decoder_outputs)\n \n # Actual backpropagation\n step_loss.backward()\n optimiser.step()\n\n step_loss = step_loss.cpu().data.numpy()\n # TODO:\n preds = preds[..., :54]\n #if current_step % 100 == 0:\n # print(\"step {0:04d}; step_loss: {1:.4f}\".format(current_step, step_loss ))\n\n step_time += (time.time() - start_time) / args.test_every\n loss += step_loss / args.test_every\n current_step += 1\n # === step decay ===\n if current_step % args.learning_rate_step == 0:\n args.learning_rate = args.learning_rate*args.learning_rate_decay_factor\n optimiser = optim.Adam(model.parameters(), lr=args.learning_rate, betas = (0.9, 0.999))\n print(\"Decay learning rate. New value at \" + str(args.learning_rate))\n\n #cuda.empty_cache()\n\n # Once in a while, we save checkpoint, print statistics, and run evals.\n if current_step % args.test_every == 0:\n model.eval()\n\n # === Validation with randomly chosen seeds ===\n encoder_inputs, decoder_inputs, decoder_outputs = clean_batch(model.get_batch( test_set, not args.omit_one_hot ))\n \n preds = model(encoder_inputs, decoder_inputs)\n mse_loss = torch.mean( (preds[..., :54] - decoder_outputs)**2)\n step_loss = get_loss(preds, decoder_outputs)\n val_loss = step_loss # Loss book-keeping\n # TODO:\n preds = preds[..., :54]\n print()\n print(\"{0: <16} |\".format(\"milliseconds\"), end=\"\")\n for ms in [80, 160, 320, 400, 560, 1000]:\n print(\" {0:5d} |\".format(ms), end=\"\")\n print()\n\n # === Validation with srnn's seeds ===\n for action in actions:\n\n # Evaluate the model on the test batches\n #### Evaluate model on action\n encoder_inputs, decoder_inputs, decoder_outputs = clean_batch(model.get_batch(test_set, action))\n \n srnn_poses = model(encoder_inputs, decoder_inputs)\n\n\n srnn_loss = get_loss(srnn_poses, decoder_outputs)\n #TODO:\n srnn_poses = srnn_poses[...,:54]\n \n srnn_poses = srnn_poses.cpu().data.numpy()\n srnn_poses = srnn_poses.transpose([1,0,2])\n\n srnn_loss = srnn_loss.cpu().data.numpy()\n # Denormalize the output\n srnn_pred_expmap = data_utils.revert_output_format( srnn_poses,\n data_mean, data_std, dim_to_ignore, actions, not args.omit_one_hot )\n\n # Save the errors here\n mean_errors = np.zeros( (len(srnn_pred_expmap), srnn_pred_expmap[0].shape[0]) )\n\n # Training is done in exponential map, but the error is reported in\n # Euler angles, as in previous work.\n # See https://github.com/asheshjain399/RNNexp/issues/6#issuecomment-247769197\n N_SEQUENCE_TEST = 8\n for i in np.arange(N_SEQUENCE_TEST):\n eulerchannels_pred = srnn_pred_expmap[i]\n\n # Convert from exponential map to Euler angles\n for j in np.arange( eulerchannels_pred.shape[0] ):\n for k in np.arange(3,97,3):\n eulerchannels_pred[j,k:k+3] = data_utils.rotmat2euler(\n data_utils.expmap2rotmat( eulerchannels_pred[j,k:k+3] ))\n\n # The global translation (first 3 entries) and global rotation\n # (next 3 entries) are also not considered in the error, so the_key\n # are set to zero.\n # See https://github.com/asheshjain399/RNNexp/issues/6#issuecomment-249404882\n gt_i=np.copy(srnn_gts_euler[action][i])\n gt_i[:,0:6] = 0\n\n # Now compute the l2 error. The following is numpy port of the error\n # function provided by Ashesh Jain (in matlab), available at\n # https://github.com/asheshjain399/RNNexp/blob/srnn/structural_rnn/CRFProblems/H3.6m/dataParser/Utils/motionGenerationError.m#L40-L54\n idx_to_use = np.where( np.std( gt_i, 0 ) > 1e-4 )[0]\n \n euc_error = np.power( gt_i[:,idx_to_use] - eulerchannels_pred[:,idx_to_use], 2)\n euc_error = np.sum(euc_error, 1)\n euc_error = np.sqrt( euc_error )\n mean_errors[i,:] = euc_error\n\n # This is simply the mean error over the N_SEQUENCE_TEST examples\n mean_mean_errors = np.mean( mean_errors, 0 )\n\n # Pretty print of the results for 80, 160, 320, 400, 560 and 1000 ms\n print(\"{0: <16} |\".format(action), end=\"\")\n for ms in [1,3,7,9,13,24]:\n if args.seq_length_out >= ms+1:\n print(\" {0:.3f} |\".format( mean_mean_errors[ms] ), end=\"\")\n else:\n print(\" n/a |\", end=\"\")\n print()\n\n print()\n print(\"============================\\n\"\n \"Global step: %d\\n\"\n \"Learning rate: %.4f\\n\"\n \"Step-time (ms): %.4f\\n\"\n \"Train loss avg: %.4f\\n\"\n \"--------------------------\\n\"\n \"Val loss: %.4f\\n\"\n \"srnn loss: %.4f\\n\"\n \"MSE loss: %.4f\\n\"\n \"============================\" % (current_step,\n args.learning_rate, step_time*1000, loss,\n val_loss, srnn_loss, mse_loss))\n with open(\"training_out.txt\", 'a+') as f:\n f.write(action + \" \" + str(current_step)+\": \"+str(val_loss)+\"\\n\")\n torch.save(model, train_dir + '/model_' + str(current_step))\n\n print()\n previous_losses.append(loss)\n\n # Reset global time and loss\n step_time, loss = 0, 0\n\n sys.stdout.flush()\n\n\ndef get_srnn_gts( actions, model, test_set, data_mean, data_std, dim_to_ignore, one_hot, to_euler=True ):\n \"\"\"\n Get the ground truths for srnn's sequences, and convert to Euler angles (by default).\n (the error is always computed in Euler angles).\n\n Args\n actions: a list of actions to get ground truths for.\n model: training model we are using (we only use the \"get_batch\" method).\n test_set: dictionary with normalized training data.\n data_mean: d-long vector with the mean of the training data.\n data_std: d-long vector with the standard deviation of the training data.\n dim_to_ignore: dimensions that we are not using to train/predict.\n one_hot: whether the data comes with one-hot encoding indicating action.\n to_euler: whether to convert the angles to Euler format or keep thm in exponential map\n\n Returns\n srnn_gts_euler: a dictionary where the keys are actions, and the values\n are the ground_truth, denormalized expected outputs of srnns's seeds.\n \"\"\"\n srnn_gts_euler = {}\n\n for action in actions:\n\n srnn_gt_euler = []\n _, _, srnn_expmap = model.get_batch_srnn( test_set, action )\n\n # expmap -> rotmat -> euler\n for i in np.arange( srnn_expmap.shape[0] ):\n denormed = data_utils.unNormalizeData(srnn_expmap[i,:,:], data_mean, data_std, dim_to_ignore, actions, one_hot )\n\n if to_euler:\n for j in np.arange( denormed.shape[0] ):\n for k in np.arange(3,97,3):\n denormed[j,k:k+3] = data_utils.rotmat2euler( data_utils.expmap2rotmat( denormed[j,k:k+3] ))\n\n srnn_gt_euler.append( denormed );\n\n # Put back in the dictionary\n srnn_gts_euler[action] = srnn_gt_euler\n\n return srnn_gts_euler\n\n\ndef sample():\n \"\"\"Sample predictions for srnn's seeds\"\"\"\n actions = define_actions( args.action )\n\n if True:\n # === Create the model ===\n print(\"Creating %d layers of %d units.\" % (args.num_layers, args.size))\n sampling = True\n model = create_model(actions, sampling)\n if not args.use_cpu:\n model = model.cuda()\n print(\"Model created\")\n\n # Load all the data\n train_set, test_set, data_mean, data_std, dim_to_ignore, dim_to_use = read_all_data(\n actions, args.seq_length_in, args.seq_length_out, args.data_dir, not args.omit_one_hot )\n\n # === Read and denormalize the gt with srnn's seeds, as we'll need them\n # many times for evaluation in Euler Angles ===\n srnn_gts_expmap = get_srnn_gts( actions, model, test_set, data_mean,\n data_std, dim_to_ignore, not args.omit_one_hot, to_euler=False )\n srnn_gts_euler = get_srnn_gts( actions, model, test_set, data_mean,\n data_std, dim_to_ignore, not args.omit_one_hot )\n # Clean and create a new h5 file of samples\n SAMPLES_FNAME = 'samples.h5'\n try:\n os.remove( SAMPLES_FNAME )\n except OSError:\n pass\n\n # Predict and save for each action\n for action in actions:\n\n # Make prediction with srnn' seeds. These will just be in expangles.\n encoder_inputs, decoder_inputs, decoder_outputs = model.get_batch_srnn( test_set, action )\n\n encoder_inputs = torch.from_numpy(encoder_inputs).float()\n decoder_inputs = torch.from_numpy(decoder_inputs).float()\n decoder_outputs = torch.from_numpy(decoder_outputs).float()\n if not args.use_cpu:\n encoder_inputs = encoder_inputs.cuda()\n decoder_inputs = decoder_inputs.cuda()\n decoder_outputs = decoder_outputs.cuda()\n encoder_inputs = Variable(encoder_inputs)\n decoder_inputs = Variable(decoder_inputs)\n decoder_outputs = Variable(decoder_outputs)\n\n srnn_poses = model(encoder_inputs, decoder_inputs)\n\n srnn_loss = (srnn_poses[..., :54] - decoder_outputs)**2\n srnn_loss.cpu().data.numpy()\n srnn_loss = srnn_loss.mean()\n\n srnn_poses = srnn_poses.cpu().data.numpy()\n srnn_poses = srnn_poses.transpose([1,0,2])\n\n srnn_loss = srnn_loss.cpu().data.numpy()\n # denormalizes too\n srnn_pred_expmap = data_utils.revert_output_format(srnn_poses[..., :54], data_mean, data_std, dim_to_ignore, actions, not args.omit_one_hot )\n\n # Save the samples\n with h5py.File( SAMPLES_FNAME, 'a' ) as hf:\n for i in np.arange(8):\n # Save conditioning ground truth\n node_name = 'expmap/gt/{1}_{0}'.format(i, action)\n hf.create_dataset( node_name, data=srnn_gts_expmap[action][i] )\n # Save prediction\n node_name = 'expmap/preds/{1}_{0}'.format(i, action)\n hf.create_dataset( node_name, data=srnn_pred_expmap[i] )\n\n # Compute and save the errors here\n mean_errors = np.zeros( (len(srnn_pred_expmap), srnn_pred_expmap[0].shape[0]) )\n\n for i in np.arange(8):\n\n eulerchannels_pred = srnn_pred_expmap[i]\n\n for j in np.arange( eulerchannels_pred.shape[0] ):\n for k in np.arange(3,97,3):\n eulerchannels_pred[j,k:k+3] = data_utils.rotmat2euler(\n data_utils.expmap2rotmat( eulerchannels_pred[j,k:k+3] ))\n\n eulerchannels_pred[:,0:6] = 0\n\n # Pick only the dimensions with sufficient standard deviation. Others are ignored.\n idx_to_use = np.where( np.std( eulerchannels_pred, 0 ) > 1e-4 )[0]\n\n euc_error = np.power( srnn_gts_euler[action][i][:,idx_to_use] - eulerchannels_pred[:,idx_to_use], 2)\n euc_error = np.sum(euc_error, 1)\n euc_error = np.sqrt( euc_error )\n mean_errors[i,:] = euc_error\n\n mean_mean_errors = np.mean( mean_errors, 0 )\n print( action )\n print( ','.join(map(str, mean_mean_errors.tolist() )) )\n\n with h5py.File( SAMPLES_FNAME, 'a' ) as hf:\n node_name = 'mean_{0}_error'.format( action )\n hf.create_dataset( node_name, data=mean_mean_errors )\n\n return\n\n\ndef define_actions( action ):\n \"\"\"\n Define the list of actions we are using.\n\n Args\n action: String with the passed action. Could be \"all\"\n Returns\n actions: List of strings of actions\n Raises\n ValueError if the action is not included in H3.6M\n \"\"\"\n\n actions = [\"walking\", \"eating\", \"smoking\", \"discussion\", \"directions\",\n \"greeting\", \"phoning\", \"posing\", \"purchases\", \"sitting\",\n \"sittingdown\", \"takingphoto\", \"waiting\", \"walkingdog\",\n \"walkingtogether\"]\n\n if action in actions:\n return [action]\n\n if action == \"all\":\n return actions\n\n if action == \"all_srnn\":\n return [\"walking\", \"eating\", \"smoking\", \"discussion\"]\n\n raise( ValueError, \"Unrecognized action: %d\" % action )\n\n\ndef read_all_data( actions, seq_length_in, seq_length_out, data_dir, one_hot ):\n \"\"\"\n Loads data for training/testing and normalizes it ALSO REMOVING UNUSED DIMENSIONS AS DEFINED IN\n normalization_stats()!\n Does nothing to rotation format.\n\n Args\n actions: list of strings (actions) to load\n seq_length_in: number of frames to use in the burn-in sequence\n seq_length_out: number of frames to use in the output sequence\n data_dir: directory to load the data from\n one_hot: whether to use one-hot encoding per action\n Returns\n train_set: dictionary with normalized training data\n test_set: dictionary with test data\n data_mean: d-long vector with the mean of the training data\n data_std: d-long vector with the standard dev of the training data\n dim_to_ignore: dimensions that are not used becaused stdev is too small\n dim_to_use: dimensions that we are actually using in the model\n \"\"\"\n\n # === Read training data ===\n print (\"Reading training data (seq_len_in: {0}, seq_len_out {1}).\".format(\n seq_length_in, seq_length_out))\n\n train_subject_ids = [1,6,7,8,9,11]\n test_subject_ids = [5]\n\n train_set, complete_train = data_utils.load_data( data_dir, train_subject_ids, actions, one_hot )\n test_set, complete_test = data_utils.load_data( data_dir, test_subject_ids, actions, one_hot )\n\n #Convert to euler angles here I guess?\n\n\n # Compute normalization stats\n data_mean, data_std, dim_to_ignore, dim_to_use = data_utils.normalization_stats(complete_train)\n\n # Normalize -- subtract mean, divide by stdev\n train_set = data_utils.normalize_data( train_set, data_mean, data_std, dim_to_use, actions, one_hot )\n test_set = data_utils.normalize_data( test_set, data_mean, data_std, dim_to_use, actions, one_hot )\n print(\"done reading data.\")\n\n return train_set, test_set, data_mean, data_std, dim_to_ignore, dim_to_use\n\n\ndef main():\n if args.sample:\n sample()\n else:\n import sys\n with open(\"training_out.txt\", 'a+') as f:\n f.write(\"============================================================\\n\"+str(sys.argv)+\"\\n\")\n\n train()\n\nif __name__ == \"__main__\":\n main()\n" ]

[ [ "torch.mean", "numpy.log", "numpy.sum", "numpy.abs", "numpy.sqrt", "numpy.power", "numpy.arange", "torch.sum", "torch.from_numpy", "torch.numel", "numpy.copy", "numpy.std", "numpy.mean", "torch.pow", "torch.autograd.Variable" ] ]

gjdv/autoimpute

[ "d22cd86db6facd4a68746c8c0fcb3fae70071dac" ]

[ "autoimpute/analysis/metrics.py" ]

[ "\"\"\"This module devises metrics to compare estimates from analysis models.\"\"\"\n\nimport numpy as np\nimport pandas as pd\n\ndef raw_bias(Q_bar, Q):\n \"\"\"Calculate raw bias between coefficients Q and actual Q.\n\n Q_bar can be one estimate (scalar) or a vector of estimates. This equation\n subtracts the expected Q_bar from Q, element-wise. The result is the bias\n of each coefficient from its true value.\n\n Args:\n Q_bar (number, array): single estimate or array of estimates.\n Q (number, array): single truth or array of truths.\n\n Returns:\n scalar, array: element-wise difference between estimates and truths.\n\n Raises:\n ValueError: Shape mismatch\n ValueError: Q_bar and Q not the same length\n \"\"\"\n\n # handle errors first\n shape_err = \"Q_bar & Q must be scalars or vectors of same length.\"\n if isinstance(Q_bar, pd.DataFrame):\n s = len(Q_bar.shape)\n if s != 1:\n raise ValueError(shape_err)\n\n if isinstance(Q, pd.DataFrame):\n s = len(Q.shape)\n if s != 1:\n raise ValueError(shape_err)\n\n if len(Q_bar) != len(Q):\n raise ValueError(shape_err)\n\n # convert any lists to ensure element-wise performed\n if isinstance(Q_bar, (tuple, list)):\n Q_bar = np.array(Q_bar)\n\n if isinstance(Q, (tuple, list)):\n Q = np.array(Q)\n\n # perform element-wise subtraction\n rb = Q_bar - Q\n return rb\n\ndef percent_bias(Q_bar, Q):\n \"\"\"Calculate precent bias between coefficients Q and actual Q.\n\n Q_bar can be one estimate (scalar) or a vector of estimates. This equation\n subtracts the expected Q_bar from Q, element-wise. The result is the bias\n of each coefficient from its true value. We then divide this number by\n Q itself, again in element-wise fashion, to produce % bias.\n\n Args:\n Q_bar (number, array): single estimate or array of estimates.\n Q (number, array): single truth or array of truths.\n\n Returns:\n scalar, array: element-wise difference between estimates and truths.\n\n Raises:\n ValueError: Shape mismatch\n ValueError: Q_bar and Q not the same length\n \"\"\"\n # calling this method will validate Q_bar and Q\n rb = raw_bias(Q_bar, Q)\n\n # convert Q if necessary. must re-perform operation\n if isinstance(Q, (tuple, list)):\n Q = np.array(Q)\n\n pct_bias = 100 * (abs(rb)/Q)\n return pct_bias\n" ]

[ [ "numpy.array" ] ]

hadleyhzy34/GANs-practice

[ "37d1dcf4e4b492e6d070b0ba72f320913af9b17a" ]

[ "gan/PyTorch-GAN-Mnist/test.py" ]

[ "import torch\nfrom torchvision import transforms\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport matplotlib.gridspec as gridspec\n\n\n\nplt.rcParams['figure.figsize'] = (10.0, 8.0)\nplt.rcParams['image.interpolation'] = 'nearest'\nplt.rcParams['image.cmap'] = 'gray'\n\n\ndef show_images(images):\n sqrtn = int(np.ceil(np.sqrt(images.shape[0])))\n\n for index, image in enumerate(images):\n plt.subplot(sqrtn, sqrtn, index+1)\n plt.imshow(image.reshape(28, 28))\n\n\ndevice = 'cuda:0' if torch.cuda.is_available() else 'cpu'\nprint('GPU State:', device)\n\n# Model\nG = torch.load('Generator_epoch_200.pth')\nG.eval()\n\n# Generator\nnoise = (torch.rand(16, 128)-0.5) / 0.5\nnoise = noise.to(device)\n\nfake_image = G(noise)\nimgs_numpy = (fake_image.data.cpu().numpy()+1.0)/2.0\nshow_images(imgs_numpy)\nplt.show()\n\n" ]

[ [ "numpy.sqrt", "torch.load", "matplotlib.pyplot.subplot", "torch.rand", "torch.cuda.is_available", "matplotlib.pyplot.show" ] ]

Diimu/circuitsimulator

[ "3a4aeaaa89b5e9bba1598736140e32b3ca1e0da4" ]

[ "circuit.py" ]

[ "# -*- coding: utf-8 -*-\n\"\"\"\nClass \"Circuit\" defines simple one port object/circuit having\nfrequency (single point or array), impedance, and possibly a list\nof components that constitute the circuit.\n\"\"\"\n\n\nimport numpy as np\nimport scipy\nimport matplotlib.pyplot as plt\nimport skrf\n\nclass Circuit:\n \n def __init__(self, f, Z, Z0=50, draw_smith=True):\n self.Z = Z\n self.f = f\n self.Z0 = Z0\n self.draw_smith=draw_smith\n self.components = [('start', Z)]\n \n\n if np.size(self.f)==1 and self.draw_smith: #single frequency -> plot transition on smith chart\n skrf.plotting.plot_smith(self.refl(self.Z), marker='o', color='k', linestyle=None, x_label='',y_label='', title='Smith chart, matching network', label='start')\n #self.components is an array of tuples containing the history of the circuit,\n #i.e., all components attached to the circuit\n\n def __str__(self):\n if not isinstance(self.f, np.ndarray):\n freq, multi = find_si_prefix(self.f)\n ret = \"{:.2f}+j{:2f} ohm at {:.2f} {:s}Hz:\\n\".format(self.Z.real, self.Z.imag, freq, multi)\n else:\n return \"not implemented for freq range\"\n \n for component in self.components:\n prefix = find_si_prefix(component[1], False)\n ct = '' #component type\n cc = '' #component connection\n unit = ''\n n = component[0]\n if n.find('cap') >= 0:\n ct = 'capacitor'\n unit = 'F'\n elif n.find('ind') >= 0:\n ct = 'inductor'\n unit = 'H'\n elif n.find('line') >= 0:\n ct = 'line'\n unit = '\\pi'\n \n if n.find('ser') >= 0:\n cc = 'Series'\n elif n.find('par') >= 0:\n cc = 'Parallel' \n elif n.find('start') >= 0:\n cc = 'Start' \n \n ret += '{:s} {:s}: {:.2f} {:s}{:s}\\n'.format(cc, ct, prefix[0], prefix[1], unit)\n \n \n \n return ret\n \n def cap(self, C):\n '''\n impedance of a capacitor at frequency of this circuit\n '''\n return cap(self.f, C)\n \n def ind(self, L):\n return ind(self.f, L)\n \n \n def refl(self, Z=None):\n '''\n returns the reflection coefficient of the present circuit\n '''\n if Z is None:\n return refl(self.Z,self.Z0)\n else:\n return refl(Z, self.Z0)\n \n def ser(self, Z):\n self.components.append(('ser',Z))\n if np.size(self.f)==1 and self.draw_smith: #single frequency -> plot transition on smith chart\n tmp = np.logspace(np.log10(Z/1000), np.log10(Z), 100)\n #impedance of a capacitance array, starting from very large cap\n #(large series capacitance == small change in impedance)\n tmp = ser(self.Z, tmp)\n #the array transformed into impedance\n\n scaled_value = find_si_prefix(Z)\n label = 'ser {:2g} {:s}$\\Omega$'.format(scaled_value[0], scaled_value[1])\n skrf.plotting.plot_smith(self.refl(tmp), x_label='',y_label='', title='Smith chart, matching network', label=label)\n \n self.Z += Z #after plotting, add series capacitance to the current impedance\n\n def par(self, Z):\n self.components.append(('par',Z))\n if np.size(self.f)==1 and self.draw_smith: #single frequency -> plot transition on smith chart\n tmp = np.logspace(np.log10(Z*1000), np.log10(Z), 100)\n #impedance of a capacitance array, starting from very large cap\n #(large series capacitance == small change in impedance)\n tmp = par(self.Z, tmp)\n #the array transformed into impedance\n\n scaled_value = find_si_prefix(Z)\n label = 'par {:2g} {:s}$\\Omega$'.format(scaled_value[0], scaled_value[1])\n skrf.plotting.plot_smith(self.refl(tmp), x_label='',y_label='', title='Smith chart, matching network', label=label)\n \n self.Z = par(Z, self.Z) #after plotting, add series capacitance to the current impedance \n \n \n def sercap(self, C):\n '''\n Set a capacitor in series with the present circuit\n '''\n self.components.append(('sercap',C))\n if np.size(self.f)==1 and self.draw_smith: #single frequency -> plot transition on smith chart\n tmp = self.cap(np.logspace(np.log10(C*1000), np.log10(C), 100)) \n #impedance of a capacitance array, starting from very large cap\n #(large series capacitance == small change in impedance)\n tmp = ser(self.Z, tmp)\n #the array transformed into impedance\n scaled_value = find_si_prefix(C)\n label = 'ser {:2g} {:s}F'.format(scaled_value[0], scaled_value[1])\n skrf.plotting.plot_smith(self.refl(tmp), x_label='',y_label='', title='Smith chart, matching network', label=label)\n \n self.Z = ser(self.Z, self.cap(C)) #after plotting, add series capacitance to the current impedance\n \n def serind(self, L):\n '''\n Set an inductor in series with the present circuit\n '''\n self.components.append(('serind',L))\n if np.size(self.f)==1 and self.draw_smith: #single frequency -> plot transition on smith chart\n tmp = self.ind(np.logspace(np.log10(L/1000), np.log10(L), 100)) \n #impedance of a capacitance array, starting from very small inductance\n tmp = ser(self.Z, tmp)\n #the array transformed into impedance\n scaled_value = find_si_prefix(L)\n label = 'ser {:2g} {:s}H'.format(scaled_value[0], scaled_value[1])\n skrf.plotting.plot_smith(self.refl(tmp), x_label='',y_label='', title='Smith chart, matching network', label=label)\n \n self.Z = ser(self.Z, self.ind(L)) #after plotting, add series inductance to the current impedance\n \n def parcap(self, C):\n '''\n Set a capacitor parallel to the present circuit\n '''\n self.components.append(('parcap',C))\n if np.size(self.f)==1 and self.draw_smith: #single frequency -> plot transition on smith chart\n tmp = self.cap(np.logspace(np.log10(C/1000), np.log10(C), 100)) \n #impedance of a capacitance array, starting from very small cap\n tmp = par(self.Z, tmp)\n #the array transformed into impedance\n scaled_value = find_si_prefix(C)\n label = 'ser {:2g} {:s}F'.format(scaled_value[0], scaled_value[1])\n skrf.plotting.plot_smith(self.refl(tmp), x_label='',y_label='', title='Smith chart, matching network', label=label)\n \n self.Z = par(self.Z, self.cap(C)) #after plotting, add series capacitance to the current impedance\n \n def parind(self, L):\n '''\n Set an inductor parallel to the present circuit\n '''\n self.components.append(('parind',L))\n if np.size(self.f)==1 and self.draw_smith: #single frequency -> plot transition on smith chart\n tmp = self.ind(np.logspace(np.log10(L*1000), np.log10(L), 100)) \n #impedance of a capacitance array, starting from very large inductance\n #(large series capacitance == small change in impedance)\n tmp = par(self.Z, tmp)\n #the array transformed into impedance\n scaled_value = find_si_prefix(L)\n label = 'par {:2g} {:s}H'.format(scaled_value[0], scaled_value[1])\n skrf.plotting.plot_smith(self.refl(tmp), x_label='',y_label='', title='Smith chart, matching network', label=label)\n \n self.Z = par(self.Z, self.ind(L)) #after plotting, add series inductance to the current impedance\n\n def serline(self, kl, Z0=None):\n '''\n perform impedance as seen through a transmission line\n '''\n if Z0==None:\n Z0=self.Z0\n\n self.components.append(('serline',kl, Z0))\n if np.size(self.f)==1 and self.draw_smith: #single frequency -> plot transition on smith chart\n tmp = line(self.Z, np.linspace(0, kl, 100), Z0) \n label = 'line {:2g}'.format(kl)\n skrf.plotting.plot_smith(self.refl(tmp), x_label='',y_label='', title='Smith chart, matching network', label=label)\n \n self.Z = line(self.Z, kl, Z0) \n\n def parline(self, kl, Zl=np.inf, Z0=None):\n '''\n add a transmission line parallel to the current impedance (defaults to open self.Z0 ohm line)\n '''\n if Z0==None:\n Z0=self.Z0\n\n self.components.append(('parline',kl, Zl, Z0))\n if np.size(self.f)==1 and self.draw_smith: #single frequency -> plot transition on smith chart\n tmp = par(self.Z, line(Zl, np.linspace(0, kl, 100), Z0))\n label = 'par line {:2g}'.format(kl)\n skrf.plotting.plot_smith(self.refl(tmp), x_label='',y_label='', title='Smith chart, matching network', label=label)\n\n self.Z = par(self.Z0, line(Zl, kl, Z0)) \n \n def db(self, noextrastuff=False):\n '''\n For a point frequency return reflection coefficient, for a frequency range\n plot the response curve. noextrastuff means the labels and grids\n '''\n if np.size(self.f)==1:\n return 20*np.log10(abs(self.refl()))\n elif noextrastuff:\n plt.plot(self.f, 20*np.log10(abs(self.refl())))\n else:\n plt.figure()\n plt.plot(self.f, 20*np.log10(np.abs(self.refl())))\n plt.ylabel('Reflection coefficient, dB')\n plt.xlabel('Frequency, Hz')\n plt.grid()\n \n def smith(self, annotations=True,smith_r=1, chart_type='z', x_label='',\n y_label='', title='Smith chart, frequency', show_legend=True,\n axis='equal', ax=None, force_chart = False, *args, **kwargs):\n '''\n plots the current mathcing network on the smith chart as the function of frequency\n '''\n if np.size(self.f)>1:\n plt.figure()\n skrf.plotting.plot_smith(self.refl(), smith_r=smith_r, chart_type=chart_type, x_label=x_label,\n y_label=y_label, title=title, show_legend=show_legend,\n axis=axis, ax=ax, force_chart = force_chart, *args, **kwargs)\n \n if annotations:\n xy=(np.real(self.refl()[0]),np.imag(self.refl()[0]))\n plt.annotate('{:.2e}'.format(self.f[0]) , xy=xy,xycoords='data', xytext=(xy[0]/ np.abs(xy[0]), xy[1]/ np.abs(xy[1])), textcoords='data', arrowprops=dict(arrowstyle=\"->\")).draggable()\n xy=(np.real(self.refl()[-1]),np.imag(self.refl()[-1]))\n plt.annotate('{:.2e}'.format(self.f[-1]) , xy=xy,xycoords='data', xytext=(xy[0]/ np.abs(xy[0]), xy[1]/ np.abs(xy[1])), textcoords='data', arrowprops=dict(arrowstyle=\"->\")).draggable()\n \n ind = np.argmin(np.abs(self.refl()))\n xy=(np.real(self.refl()[ind]),np.imag(self.refl()[ind]))\n plt.annotate('{:.2e}\\n{:.1f} dB'.format(self.f[ind], 20*np.log10(np.abs(self.refl()[ind]))) , xy=xy,xycoords='data', xytext=(xy[0]/ np.abs(xy[0])+0.2, xy[1]/ np.abs(xy[1])-0.2), textcoords='data', arrowprops=dict(arrowstyle=\"->\")).draggable()\n\n'''\nAfter this point the file defines basic equations used in Circuit class\n'''\n\ndef cap(f, C):\n '''\n impedance of a capacitor\n '''\n if isinstance(C, np.ndarray) or isinstance(f, np.ndarray):\n return 1/(1j*2*np.pi*f*C)\n elif np.iscomplex(C) or f<0 or C<0:\n raise ValueError #bullshit numbers given\n else:\n return 1/(1j*2*np.pi*f*C)\n\n\ndef ind(f, L):\n '''\n impedance of a inductor\n '''\n \n #TODO: check that input is valid. \n return 1j*2*np.pi*f*L\n\ndef ser(Z1, Z2, Z3=0, Z4=0, Z5=0, Z6=0, Z7=0, Z8=0, Z9=0, Z10=0):\n '''\n impedance of a series of compoents\n '''\n return Z1+Z2+Z3+Z4+Z5+Z6+Z7+Z8+Z9+Z10\n\ndef par(Z1, Z2, Z3=np.inf, Z4=np.inf, Z5=np.inf, Z6=np.inf, Z7=np.inf, Z8=np.inf, Z9=np.inf, Z10=np.inf):\n '''\n impedance of parallel compoents\n '''\n return 1/(1/Z1+1/Z2+1/Z3+1/Z4+1/Z5+1/Z6+1/Z7+1/Z8+1/Z9+1/Z10)\n\ndef refl(Z, Z0=50):\n if isinstance(Z, np.ndarray):\n return (Z-Z0)/(Z+Z0)\n elif Z==np.inf and Z0<np.inf:\n return 1\n else:\n return (Z-Z0)/(Z+Z0)\n \ndef find_si_prefix(x, use_latex = True):\n '''\n return (numeric value , si-prefix)\n \n >>> find_si_prefix(5000)\n (5.0, 'k')\n '''\n if use_latex:\n prefixes = ['f', 'p', 'n', '$\\mu$', 'm', '', 'k','M','G']\n else:\n prefixes = ['f', 'p', 'n', 'u', 'm', '', 'k','M','G']\n multipliers = np.asarray([1e-15,1e-12, 1e-9, 1e-6,1e-3,1,1e3,1e6,1e9])\n for n, k in enumerate(x/multipliers):\n if 0.1<k<=(100 + 1e-10):\n break #loop the list until we find a prefix that sets the k to be in nice range\n return (k, prefixes[n])\n \ndef line(Z, kl, Z0=50):\n #from scipy.special import cotdg\n if Z != np.inf:\n Z = Z0 * (Z+1j*Z0*np.tan(kl))/(Z0 + 1j* Z*np.tan(kl))\n else:\n np.seterr(divide='ignore') #lazy solution to situation kl=0 == divide by error\n Z = -1j*Z0*np.true_divide(1,np.tan(kl))# if np.tan(kl)==0 else 1j*np.inf\n #Z = -1j*Z0*np.cos(kl)/np.sin(kl)\n np.seterr(divide='warn')\n return Z \n \n\ndef db(Z, Z0=50):\n if Z==Z0: #avoid log(0)\n return -np.inf\n else:\n return 20*np.log10(abs(refl(Z, Z0)))\n \n \nif __name__ == '__main__':\n plt.ion()\n c = Circuit(64e6, 30)\n c.sercap(30e-12)\n c.parind(100e-9)\n\n\n" ]

[ [ "numpy.abs", "numpy.linspace", "numpy.asarray", "numpy.tan", "numpy.seterr", "numpy.size", "numpy.log10", "matplotlib.pyplot.ylabel", "matplotlib.pyplot.grid", "numpy.iscomplex", "matplotlib.pyplot.xlabel", "matplotlib.pyplot.ion", "matplotlib.pyplot.figure" ] ]

deepmipt/kpi2017

[ "0f6b13c6ea76e544804ce66ba372c66d5ef9ee30" ]

[ "deeppavlov/tasks/insults/build.py" ]

[ "# Copyright 2017 Neural Networks and Deep Learning lab, MIPT\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\nimport parlai.core.build_data as build_data\nimport os\nimport re\nimport string\nimport numpy as np\nimport pandas as pd\nimport urllib\n\n\ndef data_preprocessing(f):\n \"\"\"Preprocess the data.\n\n Args:\n f: list of text samples\n\n Returns:\n preprocessed list of text samples\n \"\"\"\n f = [x.lower() for x in f]\n f = [re.sub(r'^\"|\"$', '', x) for x in f]\n f = [x.replace(\"\\\\n\", \" \") for x in f]\n f = [x.replace(\"\\\\t\", \" \") for x in f]\n f = [x.replace(\"\\\\xa0\", \" \") for x in f]\n f = [x.replace(\"\\\\xc2\", \" \") for x in f]\n\n f = [re.sub('!!+', ' !! ', x) for x in f]\n f = [re.sub('!', ' ! ', x) for x in f]\n f = [re.sub('! !', '!!', x) for x in f]\n\n f = [re.sub('\\?\\?+', ' ?? ', x) for x in f]\n f = [re.sub('\\?', ' ? ', x) for x in f]\n f = [re.sub('\\? \\?', '??', x) for x in f]\n\n f = [re.sub('\\?!+', ' ?! ', x) for x in f]\n\n f = [re.sub('\\.\\.+', '..', x) for x in f]\n f = [re.sub('\\.', ' . ', x) for x in f]\n f = [re.sub('\\. \\.', '..', x) for x in f]\n\n f = [re.sub(',', ' , ', x) for x in f]\n f = [re.sub(':', ' : ', x) for x in f]\n f = [re.sub(';', ' ; ', x) for x in f]\n f = [re.sub('\\%', ' % ', x) for x in f]\n\n f = [x.replace(\"$\", \"s\") for x in f]\n f = [x.replace(\" u \", \" you \") for x in f]\n f = [x.replace(\" em \", \" them \") for x in f]\n f = [x.replace(\" da \", \" the \") for x in f]\n f = [x.replace(\" yo \", \" you \") for x in f]\n f = [x.replace(\" ur \", \" your \") for x in f]\n f = [x.replace(\"you\\'re\", \"you are\") for x in f]\n f = [x.replace(\" u r \", \" you are \") for x in f]\n f = [x.replace(\"yo\\'re\", \" you are \") for x in f]\n f = [x.replace(\"yu\\'re\", \" you are \") for x in f]\n f = [x.replace(\"u\\'re\", \" you are \") for x in f]\n f = [x.replace(\" urs \", \" yours \") for x in f]\n f = [x.replace(\"y'all\", \"you all\") for x in f]\n\n f = [x.replace(\" r u \", \" are you \") for x in f]\n f = [x.replace(\" r you\", \" are you\") for x in f]\n f = [x.replace(\" are u \", \" are you \") for x in f]\n\n f = [x.replace(\" mom \", \" mother \") for x in f]\n f = [x.replace(\" momm \", \" mother \") for x in f]\n f = [x.replace(\" mommy \", \" mother \") for x in f]\n f = [x.replace(\" momma \", \" mother \") for x in f]\n f = [x.replace(\" mama \", \" mother \") for x in f]\n f = [x.replace(\" mamma \", \" mother \") for x in f]\n f = [x.replace(\" mum \", \" mother \") for x in f]\n f = [x.replace(\" mummy \", \" mother \") for x in f]\n\n f = [x.replace(\"won't\", \"will not\") for x in f]\n f = [x.replace(\"can't\", \"cannot\") for x in f]\n f = [x.replace(\"i'm\", \"i am\") for x in f]\n f = [x.replace(\" im \", \" i am \") for x in f]\n f = [x.replace(\"ain't\", \"is not\") for x in f]\n f = [x.replace(\"'ll\", \" will\") for x in f]\n f = [x.replace(\"'t\", \" not\") for x in f]\n f = [x.replace(\"'ve\", \" have\") for x in f]\n f = [x.replace(\"'s\", \" is\") for x in f]\n f = [x.replace(\"'re\", \" are\") for x in f]\n f = [x.replace(\"'d\", \" would\") for x in f]\n\n # replace multiple letters (3 and more) by 2 letters\n for letter in string.ascii_lowercase:\n f = [re.sub(letter * 3 + '+', letter, x).strip() for x in f]\n\n bad_words_file = open(os.path.join(os.path.dirname(os.path.realpath(__file__)), \"badwords.txt\"), \"r\")\n bwMap = dict()\n for line in bad_words_file:\n sp = line.strip().lower().split(\",\")\n if len(sp) == 2:\n bwMap[sp[0].strip()] = sp[1].strip()\n\n for key, value in bwMap.items():\n kpad = \" \" + key + \" \"\n vpad = \" \" + value + \" \"\n f = [x.replace(kpad, vpad) for x in f]\n\n # stemming\n f = [re.sub(\"ies( |$)\", \"y \", x) for x in f]\n f = [re.sub(\"s( |$)\", \" \", x) for x in f]\n f = [re.sub(\"ing( |$)\", \" \", x) for x in f]\n f = [x.replace(\"tard \", \" \") for x in f]\n\n f = [re.sub(\" [*$%&#@][*$%&#@]+\", \" xexp \", x) for x in f]\n f = [re.sub(\" [0-9]+ \", \" DD \", x) for x in f]\n f = [re.sub(\"<\\S*>\", \"\", x) for x in f]\n f = [re.sub('\\s+', ' ', x) for x in f]\n return f\n\n\ndef write_input_fasttext_cls(data, path, data_name):\n \"\"\"Write down input files for fasttext classificator.\n\n Args:\n data: array of text samples\n path: path to folder to put the files\n data_name: mode of writing files \"train\" or \"test\"\n\n Returns:\n nothing\n \"\"\"\n f = open(path + '_fasttext_cls.txt', 'w')\n for i in range(data.shape[0]):\n if data_name == 'train':\n f.write('__label__' + str(data.iloc[i,0]) + ' ' + data.iloc[i,1] + '\\n')\n elif data_name == 'test':\n f.write(data.iloc[i,1] + '\\n')\n else:\n print('Incorrect data name')\n f.close()\n\n\ndef write_input_fasttext_emb(data, path, data_name):\n \"\"\"Write down input files for fasttext embedding.\n\n Args:\n data: array of text samples\n path: path to folder to put the files\n data_name: mode of writing files \"train\" or \"test\"\n\n Returns:\n nothing\n \"\"\"\n f = open(path + '_fasttext_emb.txt', 'w')\n for i in range(data.shape[0]):\n if data_name == 'train' or data_name == 'test':\n f.write(data.iloc[i,1] + '\\n')\n else:\n print('Incorrect data name')\n f.close()\n\n\ndef balance_dataset(dataset_0, labels_0, dataset_1, labels_1, ratio=1):\n \"\"\"Balance the dataset_0 with samples from dataset_1 up to given ratio.\n\n Args:\n dataset_0: array of text samples\n labels_0: array of labels for dataset_0\n dataset_1: array of text samples\n labels_1: array of labels for dataset_1\n ratio: ratio of samples of class 1 to samples of class 0 (default 1.0)\n\n Returns:\n balanced array of text samples, corresponding array of labels\n \"\"\"\n initial_train_size = dataset_0.shape[0]\n insult_inds = np.nonzero(labels_1)[0]\n num_insults_0 = len(np.nonzero(labels_0)[0])\n num_insults_1 = len(np.nonzero(labels_1)[0])\n insult_inds_to_add = insult_inds[np.random.randint(low=0, high=num_insults_1,\n size=(ratio * (initial_train_size - num_insults_0) - num_insults_0))]\n result = dataset_0.append(dataset_1.iloc[insult_inds_to_add])\n result_labels = labels_0.append(labels_1.iloc[insult_inds_to_add])\n return result, result_labels\n\n\ndef build(opt):\n \"\"\"Read and preprocess data, save preprocessed data, balance data,\n create input files for fasttext classifier and embeddings.\n\n Args:\n opt: given parameters\n\n Returns:\n nothing\n \"\"\"\n # get path to data directory\n dpath = os.path.join(opt['datapath'], 'insults')\n # define version if any\n version = '1.0'\n\n # check if data had been previously built\n if not build_data.built(dpath, version_string=version):\n print('[building data: ' + dpath + ']')\n\n # make a clean directory if needed\n if build_data.built(dpath):\n # an older version exists, so remove these outdated files.\n build_data.remove_dir(dpath)\n build_data.make_dir(dpath)\n\n raw_path = os.path.abspath(opt['raw_dataset_path'] or \".\")\n train_file = os.path.join(raw_path, 'train.csv')\n valid_file = os.path.join(raw_path, 'test_with_solutions.csv')\n test_file = os.path.join(raw_path, 'impermium_verification_labels.csv')\n if not os.path.isfile(train_file) or not os.path.isfile(valid_file) or not os.path.isfile(test_file):\n ds_path = os.environ.get('DATASETS_URL')\n file_name = 'insults.tar.gz'\n if not ds_path:\n raise RuntimeError('Please download dataset files from'\n ' https://www.kaggle.com/c/detecting-insults-in-social-commentary/data'\n ' and set path to their directory in raw-dataset-path parameter')\n print('Trying to download a insults dataset from the repository')\n url = urllib.parse.urljoin(ds_path, file_name)\n print(repr(url))\n build_data.download(url, dpath, file_name)\n build_data.untar(dpath, file_name)\n opt['raw_dataset_path'] = dpath\n print('Downloaded a insults dataset')\n\n raw_path = os.path.abspath(opt['raw_dataset_path'])\n train_file = os.path.join(raw_path, 'train.csv')\n valid_file = os.path.join(raw_path, 'test_with_solutions.csv')\n test_file = os.path.join(raw_path, 'impermium_verification_labels.csv')\n\n train_data = pd.read_csv(train_file)\n train_data = train_data.drop('Date', axis=1)\n\n test_data = pd.read_csv(test_file)\n test_data = test_data.drop('id', axis=1)\n test_data = test_data.drop('Usage', axis=1)\n test_data = test_data.drop('Date', axis=1)\n\n valid_data = pd.read_csv(valid_file)\n valid_data = valid_data.drop('Date', axis=1)\n valid_data = valid_data.drop('Usage', axis=1)\n\n # merge train and valid due to use of cross validation\n train_data = train_data.append(valid_data)\n\n if opt.get('balance_train_dataset'):\n if opt['balance_train_dataset']:\n train_data['Comment'],train_data['Insult'] = balance_dataset(train_data['Comment'],\n train_data['Insult'],\n train_data['Comment'],\n train_data['Insult'], ratio=1)\n\n print('Preprocessing train')\n train_data['Comment'] = data_preprocessing(train_data['Comment'])\n print('Preprocessing test')\n test_data['Comment'] = data_preprocessing(test_data['Comment'])\n\n print('Writing input files for fasttext')\n write_input_fasttext_cls(train_data, os.path.join(dpath, 'train'), 'train')\n write_input_fasttext_cls(test_data, os.path.join(dpath, 'test'), 'test')\n\n write_input_fasttext_emb(train_data, os.path.join(dpath, 'train'), 'train')\n write_input_fasttext_emb(test_data, os.path.join(dpath, 'test'), 'test')\n\n print('Writing input normalized input files')\n train_data.to_csv(os.path.join(dpath, 'train.csv'), index=False)\n test_data.to_csv(os.path.join(dpath, 'test.csv'), index=False)\n\n # mark the data as built\n build_data.mark_done(dpath, version_string=version)\n" ]

[ [ "pandas.read_csv", "numpy.nonzero", "numpy.random.randint" ] ]

kuldeep24680/RESTAPI-for-analyzing-data-to-excel-uploaded-file-and-downloading-resultant-csv-files-on-flask

[ "5e3f35de2599f71078974c4e5a46bb94da426200" ]

[ "routes.py" ]

[ "from app import app\r\nfrom flask import render_template, request,send_file\r\nimport pandas as pd\r\nimport csv\r\nimport xlrd\r\n\r\n\r\n\r\n# to route the user the upload the .xlsx file\r\[email protected]('/')\r\ndef upload_file():\r\n return render_template('upload.html')\r\n\r\n# function that converts the .xlsx file into .csv file and saves it into input folder as test.csv which is used for further analytics \r\[email protected]('/Fileupload', methods = ['POST'])\r\ndef upload():\r\n if request.method == 'POST':\r\n f = request.files['file']\r\n f.save(\"input/sample.xlsx\")\r\n wb = xlrd.open_workbook('input/sample.xlsx')\r\n sh = wb.sheet_by_name('Raw Data')\r\n your_csv_file = open('input/test.csv', 'w')\r\n wr = csv.writer(your_csv_file, quoting=csv.QUOTE_ALL)\r\n\r\n for rownum in range(sh.nrows):\r\n wr.writerow(sh.row_values(rownum))\r\n\r\n your_csv_file.close()\r\n\r\n\r\n return 'file uploaded successfully'\r\n# function that reads the test.csv and creates dataframe from which a filtered dataframe is generated which contains all the metabolics with suffix as PC and later write it a file\r\[email protected]('/metabolic_suffix_PC')\r\ndef metabolic_suffix_PC():\r\n column_names = pd.read_csv('input/test.csv', engine='python')\r\n columns=list(column_names.columns.values)\r\n dict={}\r\n for i in range(len(columns)):\r\n dict[i]=columns[i]\r\n\r\n\r\n csv_df = pd.read_csv('input/test.csv', header=None, skiprows=1, engine='python')\r\n child_dataset1 = csv_df[csv_df[2].str.endswith('PC', na=False)]\r\n child_dataset1.rename(columns=dict,inplace=True)\r\n tfile = open('outputs/output_PC.csv', 'w')\r\n tfile.write(child_dataset1.to_string())\r\n tfile.close()\r\n return send_file('outputs/output_PC.csv',\r\n mimetype='text/csv',\r\n attachment_filename='output_PC.csv',\r\n as_attachment=True)\r\n\r\n# function that reads the test.csv and creates dataframe from which a filtered dataframe is generated which contains all the metabolics with suffix as LPC and later write it a file\r\[email protected]('/metabolic_suffix_LPC')\r\ndef metabolic_suffix_LPC():\r\n column_names = pd.read_csv('input/test.csv', engine='python')\r\n columns=list(column_names.columns.values)\r\n dict={}\r\n for i in range(len(columns)):\r\n dict[i]=columns[i]\r\n\r\n\r\n csv_df = pd.read_csv('input/test.csv', header=None, skiprows=1, engine='python')\r\n child_dataset2 = csv_df[csv_df[2].str.endswith('LPC', na=False)]\r\n child_dataset2.rename(columns=dict,inplace=True)\r\n tfile = open('outputs/output_LPC.csv', 'w')\r\n tfile.write(child_dataset2.to_string())\r\n tfile.close()\r\n return send_file('outputs/output_LPC.csv',\r\n mimetype='text/csv',\r\n attachment_filename='output_LPC.csv',\r\n as_attachment=True)\r\n\r\n# function that reads the test.csv and creates dataframe from which a filtered dataframe is generated which contains all the metabolics with suffix as plasmalogen and later write it a file\r\[email protected]('/metabolic_suffix_plasmalogen')\r\ndef metabolic_suffix_plasmalogen():\r\n column_names = pd.read_csv('input/test.csv', engine='python')\r\n columns=list(column_names.columns.values)\r\n dict={}\r\n for i in range(len(columns)):\r\n dict[i]=columns[i]\r\n\r\n\r\n csv_df = pd.read_csv('input/test.csv', header=None, skiprows=1, engine='python')\r\n child_dataset3 = csv_df[csv_df[2].str.endswith('plasmalogen', na=False)]\r\n child_dataset3.rename(columns=dict,inplace=True)\r\n tfile = open('outputs/output_plasmalogen.csv', 'w')\r\n tfile.write(child_dataset3.to_string())\r\n tfile.close()\r\n return send_file('outputs/output_plasmalogen.csv',\r\n mimetype='text/csv',\r\n attachment_filename='output_plasmalogen.csv',\r\n as_attachment=True)\r\n# function that appends the Retention Time Roundoff column in the main dataframe and later write it a file\r\[email protected]('/parentfile_with_RTR')\r\ndef parentfile_with_RTR():\r\n column_names = pd.read_csv('input/test.csv', engine='python')\r\n columns=list(column_names.columns.values)\r\n dict={}\r\n for i in range(len(columns)):\r\n dict[i]=columns[i]\r\n\r\n\r\n csv_df = pd.read_csv('input/test.csv', header=None, skiprows=1, engine='python')\r\n csv_df[1050] = round(csv_df[1])\r\n csv_df.rename(columns={1050:'Retention Time Roundoff(in mins)'}, inplace=True)\r\n csv_df.rename(columns=dict,inplace=True)\r\n tfile = open('outputs/outputfile_with_RTR.csv', 'w')\r\n tfile.write(csv_df.to_string())\r\n tfile.close()\r\n return send_file('outputs/outputfile_with_RTR.csv',\r\n mimetype='text/csv',\r\n attachment_filename='outputfile_with_RTR.csv',\r\n as_attachment=True)\r\n# function that creates a dataframe that has mean of all metabolics readings grouped by Retention Time Roundoff(in mins) and these dataframe doesnot include unnecessary columns and finally it is written to the file\r\[email protected]('/metabolicmean_with_similarRTR')\r\ndef metabolicmean_with_similarRTR():\r\n column_names = pd.read_csv('input/test.csv', engine='python')\r\n columns=list(column_names.columns.values)\r\n dict={}\r\n for i in range(3,len(columns)):\r\n dict[i]=columns[i]\r\n csv_df = pd.read_csv('input/test.csv', header=None, skiprows=1, engine='python')\r\n csv_df[1050] = round(csv_df[1])\r\n csv_df.drop([0,1,2], axis = 1, inplace = True)\r\n csv_df.rename(columns=dict,inplace=True)\r\n\r\n\r\n\r\n csv_df.rename(columns={1050:'Retention Time Roundoff(in mins)'}, inplace=True)\r\n\r\n final =csv_df.groupby('Retention Time Roundoff(in mins)').agg('mean')\r\n\r\n tfile = open('outputs/outputfile_metabolicmean_with_similarRTR.csv', 'w')\r\n\r\n tfile.write(final.to_string())\r\n tfile.close()\r\n return send_file('outputs/outputfile_metabolicmean_with_similarRTR.csv',\r\n mimetype='text/csv',\r\n attachment_filename='outputfile_metabolicmean_with_similarRTR.csv',\r\n as_attachment=True)\r\n\r\n\r\n" ]

[ [ "pandas.read_csv" ] ]

phylatechnologies/ibd_classification_benchmark

[ "667e0b42e70bd56c6675062b10dae38407e785b0" ]

[ "run_results.py" ]

[ "import os\nimport pandas as pd\nimport numpy as np\nfrom metadata.getters import get_pwd\nfrom analysis.evaluation_methods import get_performance\nimport random\nnp.random.seed(26)\nrandom.seed(26)\ndef get_sample_info(dataset):\n '''\n :param exp_name: experiment string\n :return: unpickled data set\n '''\n\n data_file = '{}.pkl'.format(dataset)\n data_path = '{}/datasets/{}'.format(get_pwd(), data_file)\n df = pd.read_pickle(data_path)\n info = df[['diagnosis','studyID']]\n\n return info\n\nif (__name__==\"__main__\"):\n\n res_path = get_pwd() + '/results'\n res = os.listdir(res_path)\n\n\n for e in res:\n output = '{}/metrics'.format(get_pwd())\n if not os.path.isdir(output):\n os.mkdir(output)\n \n exp_name = e.split('.')[0]\n dataset = exp_name.split('-')[0]\n\n if not os.path.isfile('{}/{}.csv'.format(output, exp_name)):\n \n info = get_sample_info(dataset)\n\n file = '{}/{}'.format(res_path, e)\n\n y_pred = pd.read_csv(file, index_col=0)\n y_pred = np.round(y_pred)\n\n y = pd.concat([info, y_pred], axis = 1, sort=False)\n y.columns = ['true', 'studyID', 'pred']\n\n metrics = get_performance(y_df=y, index_name=exp_name)\n\n print(metrics)\n metrics.to_csv('{}/{}.csv'.format(output, exp_name))\n" ]

[ [ "pandas.concat", "pandas.read_csv", "numpy.random.seed", "numpy.round", "pandas.read_pickle" ] ]

Iamal1/maskrcnn-benchmark

[ "d53c1986e72c6a647179f5bf0e060db1160a1a42" ]

[ "maskrcnn_benchmark/data/datasets/coco.py" ]

[ "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\nimport torch\nimport torchvision\n\nfrom maskrcnn_benchmark.structures.bounding_box import BoxList\nfrom maskrcnn_benchmark.structures.segmentation_mask import SegmentationMask\nfrom maskrcnn_benchmark.structures.keypoint import PersonKeypoints\n\nfrom torch.distributions.beta import Beta\nfrom PIL import Image\nimport logging\nlogger = logging.getLogger(\"maskrcnn_benchmark.coco\")\nimport numpy\n\nmin_keypoints_per_image = 10\n\n\ndef _count_visible_keypoints(anno):\n return sum(sum(1 for v in ann[\"keypoints\"][2::3] if v > 0) for ann in anno)\n\n\ndef _has_only_empty_bbox(anno):\n return all(any(o <= 1 for o in obj[\"bbox\"][2:]) for obj in anno)\n\n\ndef has_valid_annotation(anno):\n # if it's empty, there is no annotation\n if len(anno) == 0:\n return False\n # if all boxes have close to zero area, there is no annotation\n if _has_only_empty_bbox(anno):\n return False\n # keypoints task have a slight different critera for considering\n # if an annotation is valid\n if \"keypoints\" not in anno[0]:\n return True\n # for keypoint detection tasks, only consider valid images those\n # containing at least min_keypoints_per_image\n if _count_visible_keypoints(anno) >= min_keypoints_per_image:\n return True\n return False\n\n\nclass COCODataset(torchvision.datasets.coco.CocoDetection):\n def __init__(\n self, ann_file, root, remove_images_without_annotations, transforms=None\n ):\n super(COCODataset, self).__init__(root, ann_file)\n # sort indices for reproducible results\n self.ids = sorted(self.ids)\n\n # filter images without detection annotations\n if remove_images_without_annotations:\n ids = []\n for img_id in self.ids:\n ann_ids = self.coco.getAnnIds(imgIds=img_id, iscrowd=None)\n anno = self.coco.loadAnns(ann_ids)\n if has_valid_annotation(anno):\n ids.append(img_id)\n self.ids = ids\n\n self.json_category_id_to_contiguous_id = {\n v: i + 1 for i, v in enumerate(self.coco.getCatIds())\n }\n self.contiguous_category_id_to_json_id = {\n v: k for k, v in self.json_category_id_to_contiguous_id.items()\n }\n self.id_to_img_map = {k: v for k, v in enumerate(self.ids)}\n self.transforms = transforms\n\n def __getitem__(self, idx):\n # '''\n # img is tensor now\n # '''\n # img_a, target_a, idx_a = self.get_one_item(idx)\n # img_b, target_b, idx_b = self.get_one_item((idx+1) % len(self.ids))\n # #merge them\n # #merge img\n # m = Beta(torch.tensor([1.5]), torch.tensor([1.5]))\n # cof_a = m.sample()\n # #cof_a = 0.5\n # c,ha,wa = img_a.shape\n # c,hb,wb = img_b.shape\n # h,w = (max(ha,hb),max(wa,wb))\n # img = img_a.new_zeros((c,h,w))\n # img[:,:ha,:wa] = cof_a * img_a\n # img[:,:hb,:wb] = (1-cof_a) * img_b\n\n # #merge labels and masks\n # boxes = torch.cat([target_a.bbox,target_b.bbox],dim=0)\n # target = BoxList(boxes, (w,h), mode=\"xyxy\")\n \n # classes = torch.cat([target_a.get_field('labels'),target_b.get_field('labels')],dim=0)\n # target.add_field(\"labels\", classes)\n\n # masks = target_a.get_field(\"masks\").instances.polygons + target_b.get_field(\"masks\").instances.polygons\n # masks = SegmentationMask(masks, (w,h), mode='poly')\n # target.add_field(\"masks\", masks)\n\n # # #add marks\n # # marks = [1]*target_a.bbox.size(0) + [0] * target_b.bbox.size(0)\n # # target.add_field(\"marks\", torch.tensor(marks))\n # cofs = [cof_a]*target_a.bbox.size(0) + [1-cof_a] * target_b.bbox.size(0)\n # target.add_field('cofs',torch.tensor(cofs))\n \n # return img, target, idx\n\n # def get_one_item(self, idx):\n img, anno = super(COCODataset, self).__getitem__(idx)\n\n # filter crowd annotations\n # TODO might be better to add an extra field\n anno = [obj for obj in anno if obj[\"iscrowd\"] == 0]\n\n boxes = [obj[\"bbox\"] for obj in anno]\n boxes = torch.as_tensor(boxes).reshape(-1, 4) # guard against no boxes\n target = BoxList(boxes, img.size, mode=\"xywh\").convert(\"xyxy\")\n\n classes = [obj[\"category_id\"] for obj in anno]\n classes = [self.json_category_id_to_contiguous_id[c] for c in classes]\n classes = torch.tensor(classes)\n target.add_field(\"labels\", classes)\n\n masks = [obj[\"segmentation\"] for obj in anno]\n masks = SegmentationMask(masks, img.size, mode='poly')\n target.add_field(\"masks\", masks)\n\n if anno and \"keypoints\" in anno[0]:\n keypoints = [obj[\"keypoints\"] for obj in anno]\n keypoints = PersonKeypoints(keypoints, img.size)\n target.add_field(\"keypoints\", keypoints)\n\n target = target.clip_to_image(remove_empty=True)\n\n if self.transforms is not None:\n img, target = self.transforms(img, target)\n\n return img, target, idx\n\n def get_img_info(self, index):\n img_id = self.id_to_img_map[index]\n img_data = self.coco.imgs[img_id]\n return img_data\n" ]

[ [ "torch.as_tensor", "torch.tensor" ] ]

wenh06/yolov4_acne_torch

[ "8eda65ff6805ec313de39c74aea12a774657f3ff" ]

[ "train_acne.py" ]

[ "# -*- coding: utf-8 -*-\n'''\ntrain acne detector using the enhanced ACNE04 dataset\n\nMore reference:\n[1] https://pytorch.org/tutorials/intermediate/torchvision_tutorial.html\n'''\nimport time\nimport logging\nimport os, sys\nimport argparse\nfrom collections import deque\nimport datetime\n\nimport cv2\nfrom tqdm import tqdm\nimport numpy as np\nimport torch\nimport torch.nn as nn\nfrom torch.utils.data import DataLoader\nfrom torch import optim\nfrom torch.nn import functional as F\nfrom tensorboardX import SummaryWriter\nfrom easydict import EasyDict as ED\n\nfrom dataset_acne04 import ACNE04\nfrom cfg_acne04 import Cfg\nfrom models import Yolov4\nfrom tool.utils_iou import (\n bboxes_iou, bboxes_giou, bboxes_diou, bboxes_ciou,\n)\nfrom tool.utils import post_processing, plot_boxes_cv2\n# from tool.tv_reference.utils import MetricLogger\nfrom tool.tv_reference.utils import collate_fn as val_collate\nfrom tool.tv_reference.coco_utils import convert_to_coco_api\nfrom tool.tv_reference.coco_eval import CocoEvaluator\n\n\nDAS = True\n\n\nclass Yolo_loss(nn.Module):\n def __init__(self, n_classes=1, n_anchors=3, device=None, batch=2, iou_type='iou'):\n super(Yolo_loss, self).__init__()\n self.device = device\n self.strides = [8, 16, 32]\n image_size = 608\n self.n_classes = n_classes\n self.n_anchors = n_anchors\n self.iou_type = iou_type\n\n self.anchors = [[12, 16], [19, 36], [40, 28], [36, 75], [76, 55], [72, 146], [142, 110], [192, 243], [459, 401]]\n # self.anchors = [[7, 7], [8, 9], [10, 8], [11, 10], [11, 12], [13, 17], [14, 11], [16, 14], [20, 21]]\n self.anch_masks = [[0, 1, 2], [3, 4, 5], [6, 7, 8]]\n self.ignore_thre = 0.5\n\n self.masked_anchors, self.ref_anchors, self.grid_x, self.grid_y, self.anchor_w, self.anchor_h = [], [], [], [], [], []\n\n for i in range(3):\n all_anchors_grid = [(w / self.strides[i], h / self.strides[i]) for w, h in self.anchors]\n masked_anchors = np.array([all_anchors_grid[j] for j in self.anch_masks[i]], dtype=np.float32)\n ref_anchors = np.zeros((len(all_anchors_grid), 4), dtype=np.float32)\n ref_anchors[:, 2:] = np.array(all_anchors_grid, dtype=np.float32)\n ref_anchors = torch.from_numpy(ref_anchors)\n # calculate pred - xywh obj cls\n fsize = image_size // self.strides[i]\n grid_x = torch.arange(fsize, dtype=torch.float).repeat(batch, 3, fsize, 1).to(device)\n grid_y = torch.arange(fsize, dtype=torch.float).repeat(batch, 3, fsize, 1).permute(0, 1, 3, 2).to(device)\n anchor_w = torch.from_numpy(masked_anchors[:, 0]).repeat(batch, fsize, fsize, 1).permute(0, 3, 1, 2).to(\n device)\n anchor_h = torch.from_numpy(masked_anchors[:, 1]).repeat(batch, fsize, fsize, 1).permute(0, 3, 1, 2).to(\n device)\n\n self.masked_anchors.append(masked_anchors)\n self.ref_anchors.append(ref_anchors)\n self.grid_x.append(grid_x)\n self.grid_y.append(grid_y)\n self.anchor_w.append(anchor_w)\n self.anchor_h.append(anchor_h)\n\n def build_target(self, pred, labels, batchsize, fsize, n_ch, output_id):\n # target assignment\n tgt_mask = torch.zeros(batchsize, self.n_anchors, fsize, fsize, 4 + self.n_classes).to(device=self.device)\n obj_mask = torch.ones(batchsize, self.n_anchors, fsize, fsize).to(device=self.device)\n tgt_scale = torch.zeros(batchsize, self.n_anchors, fsize, fsize, 2).to(self.device)\n target = torch.zeros(batchsize, self.n_anchors, fsize, fsize, n_ch).to(self.device)\n\n # labels = labels.cpu().data\n nlabel = (labels.sum(dim=2) > 0).sum(dim=1) # number of objects\n\n truth_x_all = (labels[:, :, 2] + labels[:, :, 0]) / (self.strides[output_id] * 2)\n truth_y_all = (labels[:, :, 3] + labels[:, :, 1]) / (self.strides[output_id] * 2)\n truth_w_all = (labels[:, :, 2] - labels[:, :, 0]) / self.strides[output_id]\n truth_h_all = (labels[:, :, 3] - labels[:, :, 1]) / self.strides[output_id]\n truth_i_all = truth_x_all.to(torch.int16).cpu().numpy()\n truth_j_all = truth_y_all.to(torch.int16).cpu().numpy()\n\n for b in range(batchsize):\n n = int(nlabel[b])\n if n == 0:\n continue\n truth_box = torch.zeros(n, 4).to(self.device)\n truth_box[:n, 2] = truth_w_all[b, :n]\n truth_box[:n, 3] = truth_h_all[b, :n]\n truth_i = truth_i_all[b, :n]\n truth_j = truth_j_all[b, :n]\n\n # calculate iou between truth and reference anchors\n # anchor_ious_all = bboxes_iou(truth_box.cpu(), self.ref_anchors[output_id])\n anchor_ious_all = bboxes_iou(\n truth_box.cpu(),\n self.ref_anchors[output_id],\n fmt='voc',\n # iou_type='iou',\n iou_type=self.iou_type,\n )\n best_n_all = anchor_ious_all.argmax(dim=1)\n best_n = best_n_all % 3\n best_n_mask = ((best_n_all == self.anch_masks[output_id][0]) |\n (best_n_all == self.anch_masks[output_id][1]) |\n (best_n_all == self.anch_masks[output_id][2]))\n\n if sum(best_n_mask) == 0:\n continue\n\n truth_box[:n, 0] = truth_x_all[b, :n]\n truth_box[:n, 1] = truth_y_all[b, :n]\n\n # pred_ious = bboxes_iou(pred[b].view(-1, 4), truth_box, xyxy=False)\n pred_ious = bboxes_iou(\n pred[b].view(-1, 4),\n truth_box,\n fmt='yolo',\n # iou_type='iou',\n iou_type=self.iou_type,\n )\n pred_best_iou, _ = pred_ious.max(dim=1)\n pred_best_iou = (pred_best_iou > self.ignore_thre)\n pred_best_iou = pred_best_iou.view(pred[b].shape[:3])\n # set mask to zero (ignore) if pred matches truth\n obj_mask[b] = ~ pred_best_iou\n\n for ti in range(best_n.shape[0]):\n if best_n_mask[ti] == 1:\n i, j = truth_i[ti], truth_j[ti]\n a = best_n[ti]\n obj_mask[b, a, j, i] = 1\n tgt_mask[b, a, j, i, :] = 1\n target[b, a, j, i, 0] = truth_x_all[b, ti] - truth_x_all[b, ti].to(torch.int16).to(torch.float)\n target[b, a, j, i, 1] = truth_y_all[b, ti] - truth_y_all[b, ti].to(torch.int16).to(torch.float)\n target[b, a, j, i, 2] = torch.log(\n truth_w_all[b, ti] / torch.Tensor(self.masked_anchors[output_id])[best_n[ti], 0] + 1e-16)\n target[b, a, j, i, 3] = torch.log(\n truth_h_all[b, ti] / torch.Tensor(self.masked_anchors[output_id])[best_n[ti], 1] + 1e-16)\n target[b, a, j, i, 4] = 1\n target[b, a, j, i, 5 + labels[b, ti, 4].to(torch.int16).cpu().numpy()] = 1\n tgt_scale[b, a, j, i, :] = torch.sqrt(2 - truth_w_all[b, ti] * truth_h_all[b, ti] / fsize / fsize)\n return obj_mask, tgt_mask, tgt_scale, target\n\n def forward(self, xin, labels=None):\n loss, loss_xy, loss_wh, loss_obj, loss_cls, loss_l2 = 0, 0, 0, 0, 0, 0\n for output_id, output in enumerate(xin):\n batchsize = output.shape[0]\n fsize = output.shape[2]\n n_ch = 5 + self.n_classes\n\n output = output.view(batchsize, self.n_anchors, n_ch, fsize, fsize)\n output = output.permute(0, 1, 3, 4, 2) # .contiguous()\n\n # logistic activation for xy, obj, cls\n output[..., np.r_[:2, 4:n_ch]] = torch.sigmoid(output[..., np.r_[:2, 4:n_ch]])\n\n pred = output[..., :4].clone()\n pred[..., 0] += self.grid_x[output_id]\n pred[..., 1] += self.grid_y[output_id]\n pred[..., 2] = torch.exp(pred[..., 2]) * self.anchor_w[output_id]\n pred[..., 3] = torch.exp(pred[..., 3]) * self.anchor_h[output_id]\n\n obj_mask, tgt_mask, tgt_scale, target = self.build_target(\n pred, labels, batchsize, fsize, n_ch, output_id\n )\n\n # loss calculation\n output[..., 4] *= obj_mask\n output[..., np.r_[0:4, 5:n_ch]] *= tgt_mask\n output[..., 2:4] *= tgt_scale\n\n target[..., 4] *= obj_mask\n target[..., np.r_[0:4, 5:n_ch]] *= tgt_mask\n target[..., 2:4] *= tgt_scale\n\n loss_xy += F.binary_cross_entropy(\n input=output[..., :2],\n target=target[..., :2],\n weight=tgt_scale*tgt_scale,\n size_average=False,\n )\n loss_wh += F.mse_loss(input=output[..., 2:4], target=target[..., 2:4], size_average=False) / 2\n loss_obj += F.binary_cross_entropy(input=output[..., 4], target=target[..., 4], size_average=False)\n loss_cls += F.binary_cross_entropy(input=output[..., 5:], target=target[..., 5:], size_average=False)\n loss_l2 += F.mse_loss(input=output, target=target, size_average=False)\n\n loss = loss_xy + loss_wh + loss_obj + loss_cls\n\n return loss, loss_xy, loss_wh, loss_obj, loss_cls, loss_l2\n\n\ndef collate(batch):\n images = []\n bboxes = []\n for img, box in batch:\n images.append([img])\n bboxes.append([box])\n images = np.concatenate(images, axis=0)\n images = images.transpose(0, 3, 1, 2)\n images = torch.from_numpy(images).div(255.0)\n bboxes = np.concatenate(bboxes, axis=0)\n bboxes = torch.from_numpy(bboxes)\n return images, bboxes\n\n\ndef train(model, device, config, epochs=5, batch_size=1, save_ckpt=True, log_step=20, logger=None, img_scale=0.5):\n \"\"\"\n \"\"\"\n train_dataset = ACNE04(label_path=config.train_label, cfg=config, train=True)\n val_dataset = ACNE04(label_path=config.val_label, cfg=config, train=False)\n\n n_train = len(train_dataset)\n n_val = len(val_dataset)\n\n train_loader = DataLoader(\n dataset=train_dataset,\n batch_size=config.batch // config.subdivisions,\n shuffle=True,\n num_workers=8,\n pin_memory=True,\n drop_last=True, # setting False would result in error\n collate_fn=collate,\n )\n\n val_loader = DataLoader(\n dataset=val_dataset,\n batch_size=config.batch // config.subdivisions,\n shuffle=True,\n num_workers=8,\n pin_memory=True,\n drop_last=True, # setting False would result in error\n collate_fn=val_collate,\n )\n\n writer = SummaryWriter(\n log_dir=config.TRAIN_TENSORBOARD_DIR,\n filename_suffix=f'OPT_{config.TRAIN_OPTIMIZER}_LR_{config.learning_rate}_BS_{config.batch}_Sub_{config.subdivisions}_Size_{config.width}',\n comment=f'OPT_{config.TRAIN_OPTIMIZER}_LR_{config.learning_rate}_BS_{config.batch}_Sub_{config.subdivisions}_Size_{config.width}',\n )\n \n max_itr = config.TRAIN_EPOCHS * n_train\n # global_step = cfg.TRAIN_MINEPOCH * n_train\n global_step = 0\n if logger:\n logger.info(f'''Starting training:\n Epochs: {epochs}\n Batch size: {config.batch}\n Subdivisions: {config.subdivisions}\n Learning rate: {config.learning_rate}\n Training size: {n_train}\n Validation size: {n_val}\n Checkpoints: {save_ckpt}\n Device: {device.type}\n Images size: {config.width}\n Optimizer: {config.TRAIN_OPTIMIZER}\n Dataset classes: {config.classes}\n Train label path:{config.train_label}\n Pretrained: {config.pretrained}\n ''')\n\n # learning rate setup\n def burnin_schedule(i):\n if i < config.burn_in:\n factor = pow(i / config.burn_in, 4)\n elif i < config.steps[0]:\n factor = 1.0\n elif i < config.steps[1]:\n factor = 0.1\n else:\n factor = 0.01\n return factor\n\n if config.TRAIN_OPTIMIZER.lower() == 'adam':\n optimizer = optim.Adam(\n params=model.parameters(),\n lr=config.learning_rate / config.batch,\n betas=(0.9, 0.999),\n eps=1e-08,\n )\n elif config.TRAIN_OPTIMIZER.lower() == 'sgd':\n optimizer = optim.SGD(\n params=model.parameters(),\n lr=config.learning_rate / config.batch,\n momentum=config.momentum,\n weight_decay=config.decay,\n )\n scheduler = optim.lr_scheduler.LambdaLR(optimizer, burnin_schedule)\n\n criterion = Yolo_loss(\n n_classes=config.classes,\n device=device,\n batch=config.batch // config.subdivisions,\n iou_type=config.iou_type,\n )\n # scheduler = ReduceLROnPlateau(optimizer, mode='max', verbose=True, patience=6, min_lr=1e-7)\n # scheduler = CosineAnnealingWarmRestarts(optimizer, 0.001, 1e-6, 20)\n\n save_prefix = 'Yolov4_epoch'\n saved_models = deque()\n model.train()\n\n for epoch in range(epochs):\n model.train()\n epoch_loss = 0\n epoch_step = 0\n\n with tqdm(total=n_train, desc=f'Epoch {epoch + 1}/{epochs}', unit='img', ncols=100) as pbar:\n for i, batch in enumerate(train_loader):\n global_step += 1\n epoch_step += 1\n images = batch[0]\n bboxes = batch[1]\n\n images = images.to(device=device, dtype=torch.float32)\n bboxes = bboxes.to(device=device)\n\n bboxes_pred = model(images)\n loss, loss_xy, loss_wh, loss_obj, loss_cls, loss_l2 = criterion(bboxes_pred, bboxes)\n # loss = loss / config.subdivisions\n loss.backward()\n\n epoch_loss += loss.item()\n\n if global_step % config.subdivisions == 0:\n optimizer.step()\n scheduler.step()\n model.zero_grad()\n\n if global_step % (log_step * config.subdivisions) == 0:\n writer.add_scalar('train/Loss', loss.item(), global_step)\n writer.add_scalar('train/loss_xy', loss_xy.item(), global_step)\n writer.add_scalar('train/loss_wh', loss_wh.item(), global_step)\n writer.add_scalar('train/loss_obj', loss_obj.item(), global_step)\n writer.add_scalar('train/loss_cls', loss_cls.item(), global_step)\n writer.add_scalar('train/loss_l2', loss_l2.item(), global_step)\n writer.add_scalar('lr', scheduler.get_lr()[0] * config.batch, global_step)\n pbar.set_postfix(**{\n 'loss (batch)': loss.item(),\n 'loss_xy': loss_xy.item(),\n 'loss_wh': loss_wh.item(),\n 'loss_obj': loss_obj.item(),\n 'loss_cls': loss_cls.item(),\n 'loss_l2': loss_l2.item(),\n 'lr': scheduler.get_lr()[0] * config.batch\n })\n if logger:\n logger.info(f'Train step_{global_step}: loss : {loss.item()},loss xy : {loss_xy.item()}, loss wh : {loss_wh.item()}, loss obj : {loss_obj.item()}, loss cls : {loss_cls.item()}, loss l2 : {loss_l2.item()}, lr : {scheduler.get_lr()[0] * config.batch}')\n\n pbar.update(images.shape[0])\n \n # TODO: eval for each epoch using `evaluate`\n eval_model = Yolov4(yolov4conv137weight=None, n_classes=config.classes, inference=True)\n eval_model.load_state_dict(model.state_dict())\n eval_model.to(device)\n evaluator = evaluate(eval_model, val_loader, config, device, logger)\n del eval_model\n\n stats = evaluator.coco_eval['bbox'].stats\n writer.add_scalar('train/AP', stats[0], global_step)\n writer.add_scalar('train/AP50', stats[1], global_step)\n writer.add_scalar('train/AP75', stats[2], global_step)\n writer.add_scalar('train/AP_small', stats[3], global_step)\n writer.add_scalar('train/AP_medium', stats[4], global_step)\n writer.add_scalar('train/AP_large', stats[5], global_step)\n writer.add_scalar('train/AR1', stats[6], global_step)\n writer.add_scalar('train/AR10', stats[7], global_step)\n writer.add_scalar('train/AR100', stats[8], global_step)\n writer.add_scalar('train/AR_small', stats[9], global_step)\n writer.add_scalar('train/AR_medium', stats[10], global_step)\n writer.add_scalar('train/AR_large', stats[11], global_step)\n\n if save_ckpt:\n try:\n os.mkdir(config.checkpoints)\n if logger:\n logger.info('Created checkpoint directory')\n except OSError:\n pass\n save_path = os.path.join(config.checkpoints, f'{save_prefix}{epoch + 1}_{_get_date_str()}.pth')\n torch.save(model.state_dict(), save_path)\n if logger:\n logger.info(f'Checkpoint {epoch + 1} saved!')\n saved_models.append(save_path)\n # remove outdated models\n if len(saved_models) > config.keep_checkpoint_max > 0:\n model_to_remove = saved_models.popleft()\n try:\n os.remove(model_to_remove)\n except:\n logger.info(f'failed to remove {model_to_remove}')\n\n writer.close()\n\n\[email protected]_grad()\ndef evaluate(model, data_loader, cfg, device, logger=None, **kwargs):\n \"\"\" finished, tested\n \"\"\"\n # cpu_device = torch.device(\"cpu\")\n model.eval()\n # header = 'Test:'\n\n coco = convert_to_coco_api(data_loader.dataset, bbox_fmt='coco')\n coco_evaluator = CocoEvaluator(coco, iou_types = [\"bbox\"], bbox_fmt='coco')\n\n for images, targets in data_loader:\n model_input = [[cv2.resize(img, (cfg.w, cfg.h))] for img in images]\n model_input = np.concatenate(model_input, axis=0)\n model_input = model_input.transpose(0, 3, 1, 2)\n model_input = torch.from_numpy(model_input).div(255.0)\n model_input = model_input.to(device)\n targets = [{k: v.to(device) for k, v in t.items()} for t in targets]\n\n if torch.cuda.is_available():\n torch.cuda.synchronize()\n model_time = time.time()\n outputs = model(model_input)\n\n # outputs = [{k: v.to(cpu_device) for k, v in t.items()} for t in outputs]\n model_time = time.time() - model_time\n\n # outputs = outputs.cpu().detach().numpy()\n res = {}\n # for img, target, output in zip(images, targets, outputs):\n for img, target, boxes, confs in zip(images, targets, outputs[0], outputs[1]):\n img_height, img_width = img.shape[:2]\n # boxes = output[...,:4].copy() # output boxes in yolo format\n boxes = boxes.squeeze(2).cpu().detach().numpy()\n boxes[...,2:] = boxes[...,2:] - boxes[...,:2] # Transform [x1, y1, x2, y2] to [x1, y1, w, h]\n boxes[...,0] = boxes[...,0]*img_width\n boxes[...,1] = boxes[...,1]*img_height\n boxes[...,2] = boxes[...,2]*img_width\n boxes[...,3] = boxes[...,3]*img_height\n boxes = torch.as_tensor(boxes, dtype=torch.float32)\n # confs = output[...,4:].copy()\n confs = confs.cpu().detach().numpy()\n labels = np.argmax(confs, axis=1).flatten()\n labels = torch.as_tensor(labels, dtype=torch.int64)\n scores = np.max(confs, axis=1).flatten()\n scores = torch.as_tensor(scores, dtype=torch.float32)\n res[target[\"image_id\"].item()] = {\n \"boxes\": boxes,\n \"scores\": scores,\n \"labels\": labels,\n }\n\n debug = kwargs.get(\"debug\", [])\n if isinstance(debug, str):\n debug = [debug]\n debug = [item.lower() for item in debug]\n if 'iou' in debug:\n from tool.utils_iou_test import bboxes_iou_test\n ouput_boxes = np.array(post_processing(None, 0.5, 0.5, outputs)[0])[...,:4]\n img_height, img_width = images[0].shape[:2]\n ouput_boxes[...,0] = ouput_boxes[...,0] * img_width\n ouput_boxes[...,1] = ouput_boxes[...,1] * img_height\n ouput_boxes[...,2] = ouput_boxes[...,2] * img_width\n ouput_boxes[...,3] = ouput_boxes[...,3] * img_height\n # coco format to yolo format\n truth_boxes = targets[0]['boxes'].numpy().copy()\n truth_boxes[...,:2] = truth_boxes[...,:2] + truth_boxes[...,2:]/2\n iou = bboxes_iou_test(torch.Tensor(ouput_boxes), torch.Tensor(truth_boxes), fmt='yolo')\n print(f\"iou of first image = {iou}\")\n if len(debug) > 0:\n return\n \n evaluator_time = time.time()\n coco_evaluator.update(res)\n evaluator_time = time.time() - evaluator_time\n\n # gather the stats from all processes\n coco_evaluator.synchronize_between_processes()\n\n # accumulate predictions from all images\n coco_evaluator.accumulate()\n coco_evaluator.summarize()\n\n return coco_evaluator\n\n\ndef get_args(**kwargs):\n \"\"\"\n \"\"\"\n pretrained_detector = '/mnt/wenhao71/workspace/yolov4_acne_torch/pretrained/yolov4.pth'\n cfg = kwargs\n parser = argparse.ArgumentParser(\n description='Train the Model on images and target masks',\n formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n # parser.add_argument(\n # '-b', '--batch-size',\n # metavar='B', type=int, nargs='?', default=2,\n # help='Batch size',\n # dest='batchsize')\n parser.add_argument(\n '-l', '--learning-rate',\n metavar='LR', type=float, nargs='?', default=0.001,\n help='Learning rate',\n dest='learning_rate')\n parser.add_argument(\n '-f', '--load',\n dest='load', type=str, default=pretrained_detector,\n help='Load model from a .pth file')\n parser.add_argument(\n '-g', '--gpu',\n metavar='G', type=str, default='0',\n help='GPU',\n dest='gpu')\n # `dataset_dir` and `pretrained` already set in cfg_acne04.py\n # parser.add_argument(\n # '-dir', '--data-dir',\n # type=str, default=None,\n # help='dataset dir', dest='dataset_dir')\n # parser.add_argument(\n # '-pretrained',\n # type=str, default=None,\n # help='pretrained yolov4.conv.137')\n parser.add_argument(\n '-classes',\n type=int, default=1,\n help='dataset classes')\n # parser.add_argument(\n # '-train_label_path',\n # dest='train_label', type=str, default='train.txt',\n # help=\"train label path\")\n parser.add_argument(\n '-iou-type', type=str, default='iou',\n help='iou type (iou, giou, diou, ciou)',\n dest='iou_type')\n parser.add_argument(\n '-keep-checkpoint-max', type=int, default=10,\n help='maximum number of checkpoints to keep. If set 0, all checkpoints will be kept',\n dest='keep_checkpoint_max')\n parser.add_argument(\n '-optimizer', type=str, default='adam',\n help='training optimizer',\n dest='TRAIN_OPTIMIZER')\n \n args = vars(parser.parse_args())\n\n cfg.update(args)\n \n return ED(cfg)\n\n\ndef init_logger(log_file=None, log_dir=None, mode='a', verbose=0):\n \"\"\"\n \"\"\"\n if log_dir is None:\n log_dir = '~/temp/log/'\n if log_file is None:\n log_file = f'log_{_get_date_str()}.txt'\n if not os.path.exists(log_dir):\n os.makedirs(log_dir)\n log_file = os.path.join(log_dir, log_file)\n print(f'log file path: {log_file}')\n\n logger = logging.getLogger('Yolov4-ACNE04')\n\n c_handler = logging.StreamHandler(sys.stdout)\n f_handler = logging.FileHandler(log_file)\n\n if verbose >= 2:\n print(\"levels of c_handler and f_handler are set DEBUG\")\n c_handler.setLevel(logging.DEBUG)\n f_handler.setLevel(logging.DEBUG)\n logger.setLevel(logging.DEBUG)\n elif verbose >= 1:\n print(\"level of c_handler is set INFO, level of f_handler is set DEBUG\")\n c_handler.setLevel(logging.INFO)\n f_handler.setLevel(logging.DEBUG)\n logger.setLevel(logging.DEBUG)\n else:\n print(\"levels of c_handler and f_handler are set WARNING\")\n c_handler.setLevel(logging.WARNING)\n f_handler.setLevel(logging.WARNING)\n logger.setLevel(logging.WARNING)\n\n c_format = logging.Formatter('%(name)s - %(levelname)s - %(message)s')\n f_format = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')\n c_handler.setFormatter(c_format)\n f_handler.setFormatter(f_format)\n\n logger.addHandler(c_handler)\n logger.addHandler(f_handler)\n\n return logger\n\n\ndef _get_date_str():\n now = datetime.datetime.now()\n return now.strftime('%Y-%m-%d_%H-%M')\n\n\n\"\"\"\ntorch, torch vision, cu compatibility:\nhttps://download.pytorch.org/whl/torch_stable.html\nhttps://download.pytorch.org/whl/cu100/torch-1.3.1%2Bcu100-cp36-cp36m-linux_x86_64.whl\n\"\"\"\n\nif __name__ == \"__main__\":\n cfg = get_args(**Cfg)\n # os.environ[\"CUDA_VISIBLE_DEVICES\"] = cfg.gpu\n if not DAS:\n device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n else:\n device = torch.device('cuda')\n log_dir = cfg.TRAIN_TENSORBOARD_DIR\n logger = init_logger(log_dir=log_dir)\n logger.info(f\"\\n{'*'*20} Start Training {'*'*20}\\n\")\n logger.info(f'Using device {device}')\n logger.info(f\"Using torch of version {torch.__version__}\")\n logger.info(f'with configuration {cfg}')\n print(f\"\\n{'*'*20} Start Training {'*'*20}\\n\")\n print(f'Using device {device}')\n print(f\"Using torch of version {torch.__version__}\")\n print(f'with configuration {cfg}')\n\n model = Yolov4(cfg.pretrained, n_classes=cfg.classes)\n\n if not DAS and torch.cuda.device_count() > 1:\n model = torch.nn.DataParallel(model)\n if not DAS:\n model.to(device=device)\n else:\n model.cuda()\n\n try:\n train(\n model=model,\n config=cfg,\n epochs=cfg.TRAIN_EPOCHS,\n device=device,\n logger=logger,\n )\n except KeyboardInterrupt:\n torch.save(model.state_dict(), os.path.join(cfg.checkpoints, 'INTERRUPTED.pth'))\n logger.info('Saved interrupt')\n try:\n sys.exit(0)\n except SystemExit:\n os._exit(0)\n" ]

[ [ "torch.optim.lr_scheduler.LambdaLR", "torch.zeros", "torch.utils.data.DataLoader", "numpy.concatenate", "numpy.max", "torch.no_grad", "torch.cuda.is_available", "torch.device", "torch.cuda.synchronize", "torch.ones", "torch.sqrt", "torch.from_numpy", "numpy.argmax", "torch.arange", "torch.sigmoid", "torch.exp", "torch.nn.functional.mse_loss", "torch.cuda.device_count", "numpy.array", "torch.as_tensor", "torch.Tensor", "torch.nn.functional.binary_cross_entropy", "torch.nn.DataParallel" ] ]

ayushmaskey/log_analysis

[ "c777f48117ec8e14845aa8d2deccc7f974ca232a" ]

[ "app/analysis/validation_cluster.py" ]

[ "import pandas as pd\nimport matplotlib.pyplot as plt\nfrom matplotlib import style\nstyle.use(\"ggplot\")\n\nfrom csv_to_pandas import csv_into_dict_of_data\nfrom wavelet_transformation import csv_into_wavelet_transformed_dict_of_dataframe\n\nfrom training_cluster import reorganize_data\n\ndef get_validation_dataset(df):\n\tcolumn_list = [col for col in df.columns if col >= '2019-03-01']\n\tdf = reorganize_data(df, column_list)\n\treturn df\n\n\ndef vaidation():\n\tdf_dict = csv_into_dict_of_data()\n\t\n\tkey_list = list(df_dict.keys())\n\tfor key in key_list:\n\t\tdf = get_validation_dataset(df_dict[key])\n\t\tdf_dict[key] = df\n\n\treturn df_dict\n\ndef test_new_df_dict():\n\tdf_dict = vaidation()\n\n\tkey_list = list(df_dict.keys())\n\tprint(key_list)\n\tfor key in key_list:\n\t\tprint(key, list(df_dict[key].columns))\n\n\nif __name__ == \"__main__\":\n\n\ttest_new_df_dict()" ]

[ [ "matplotlib.style.use" ] ]

maremun/mix-attend-break-sticks

[ "db8221447fb993194641ba781e85005180f55421" ]

[ "transformer.py" ]

[ "import torch\nimport torch.nn as nn\n\nfrom modules import Linear, PosEncoding\nfrom layers import DecoderLayer\n\nimport const\n\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n\n\ndef proj_prob_simplex(inputs):\n # project updated weights onto a probability simplex\n # see https://arxiv.org/pdf/1101.6081.pdf\n sorted_inputs, sorted_idx = torch.sort(inputs.view(-1), descending=True)\n dim = len(sorted_inputs)\n for i in reversed(range(dim)):\n t = (sorted_inputs[:i+1].sum() - 1) / (i+1)\n if sorted_inputs[i] > t:\n break\n return torch.clamp(inputs-t, min=0.0)\n\n\ndef get_attn_pad_mask(seq_q, seq_k):\n assert seq_q.dim() == 2 and seq_k.dim() == 2\n b_size, len_q = seq_q.size()\n b_size, len_k = seq_k.size()\n #pad_attn_mask = seq_k.eq(const.PAD).unsqueeze(1) # b_size x 1 x len_k\n pad_attn_mask = seq_k.eq(-1).unsqueeze(1) # b_size x 1 x len_k\n pad_attn_mask = pad_attn_mask.expand(b_size, len_q, len_k) # b_size x len_q x len_k\n return pad_attn_mask\n\n\ndef get_attn_subsequent_mask(seq):\n assert seq.dim() == 2\n attn_shape = [seq.size(1), seq.size(1)]\n subsequent_mask = torch.triu(torch.ones(attn_shape, device=device), diagonal=1).byte()\n return subsequent_mask\n\n\nclass Decoder(nn.Module):\n def __init__(self, n_layers, d_k, d_v, d_model, d_ff, n_heads,\n max_seq_len, tgt_vocab_size, dropout=0.1, weighted=False):\n super(Decoder, self).__init__()\n self.d_model = d_model\n self.tgt_emb = nn.Embedding(tgt_vocab_size, d_model) #, padding_idx=const.PAD)\n self.pos_emb = PosEncoding(max_seq_len * 10, d_model) # TODO: *10 fix\n self.dropout_emb = nn.Dropout(dropout)\n self.layer_type = DecoderLayer if not weighted else WeightedDecoderLayer\n self.layers = nn.ModuleList(\n [self.layer_type(d_k, d_v, d_model, d_ff, n_heads, dropout) for _ in range(n_layers)])\n\n \n def forward(self, dec_inputs, dec_inputs_len, enc_inputs, enc_outputs, return_attn=False):\n dec_outputs = self.tgt_emb(dec_inputs)\n dec_outputs += self.pos_emb(dec_inputs_len)\n dec_outputs = self.dropout_emb(dec_outputs)\n\n dec_self_attn_pad_mask = get_attn_pad_mask(dec_inputs, dec_inputs)\n dec_self_attn_subsequent_mask = get_attn_subsequent_mask(dec_inputs)\n\n dec_self_attn_mask = torch.gt((dec_self_attn_pad_mask + dec_self_attn_subsequent_mask), 0)\n if enc_inputs is not None:\n dec_enc_attn_pad_mask = get_attn_pad_mask(dec_inputs, enc_inputs)\n else:\n dec_enc_attn_pad_mask = None\n\n dec_self_attns, dec_enc_attns = [], []\n for layer in self.layers:\n dec_outputs, dec_self_attn, dec_enc_attn = layer(dec_outputs, enc_outputs,\n self_attn_mask=dec_self_attn_mask,\n enc_attn_mask=dec_enc_attn_pad_mask)\n if return_attn:\n dec_self_attns.append(dec_self_attn)\n dec_enc_attns.append(dec_enc_attn)\n\n return dec_outputs, dec_self_attns, dec_enc_attns\n\n\nclass LMTransformer(nn.Module):\n def __init__(self, n_layers, d_k, d_v, d_model, d_ff, n_heads,\n max_tgt_seq_len, tgt_vocab_size, dropout,\n weighted_model, share_proj_weight):\n super(LMTransformer, self).__init__()\n self.decoder = Decoder(n_layers, d_k, d_v, d_model, d_ff, n_heads,\n max_tgt_seq_len, tgt_vocab_size, dropout, weighted_model)\n self.tgt_proj = Linear(d_model, tgt_vocab_size, bias=False)\n self.weighted_model = weighted_model\n\n if share_proj_weight:\n print('Sharing target embedding and projection..')\n self.tgt_proj.weight = self.decoder.tgt_emb.weight\n\n\n def trainable_params(self):\n # Avoid updating the position encoding\n params = filter(lambda p: p[1].requires_grad, self.named_parameters())\n # Add a separate parameter group for the weighted_model\n param_groups = []\n base_params = {'params': [], 'type': 'base'}\n weighted_params = {'params': [], 'type': 'weighted'}\n for name, param in params:\n if 'w_kp' in name or 'w_a' in name:\n weighted_params['params'].append(param)\n else:\n base_params['params'].append(param)\n param_groups.append(base_params)\n param_groups.append(weighted_params)\n return param_groups\n\n \n def decode(self, dec_inputs, dec_inputs_len, enc_inputs, enc_outputs, return_attn=False):\n return self.decoder(dec_inputs, dec_inputs_len, enc_inputs, enc_outputs, return_attn)\n\n \n def forward(self, dec_inputs, dec_inputs_len, return_attn=False):\n dec_outputs, dec_self_attns, _ = \\\n self.decoder(dec_inputs, dec_inputs_len, None, None, return_attn)\n dec_logits = self.tgt_proj(dec_outputs)\n return dec_logits.view(-1, dec_logits.size(-1)), dec_self_attns\n\n \n def proj_grad(self):\n if self.weighted_model:\n for name, param in self.named_parameters():\n if 'w_kp' in name or 'w_a' in name:\n param.data = proj_prob_simplex(param.data)\n else:\n pass\n" ]

[ [ "torch.nn.Dropout", "torch.ones", "torch.nn.Embedding", "torch.cuda.is_available", "torch.clamp", "torch.gt" ] ]

christostsekouronas/academyposttestanalysis

[ "913a0c13ad0482927a323b2fb3a97a8e2ca26517" ]

[ "loadCSVdata.py" ]

[ "import pandas as pd\n\n\n\ndef loadTest(filepath):\n df = pd.read_csv(filepath)\n return df" ]

[ [ "pandas.read_csv" ] ]

juliandwain/deepmind-research

[ "eca5fe66ad770027f4dd758d3a659cd8261bace5" ]

[ "meshgraphnets/cloth_model.py" ]

[ "# Lint as: python3\n# pylint: disable=g-bad-file-header\n# Copyright 2020 DeepMind Technologies Limited. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ============================================================================\n\"\"\"Model for FlagSimple.\"\"\"\n\nimport sonnet as snt\nimport tensorflow.compat.v1 as tf\n\nimport common\nimport core_model\nimport normalization\n\nclass Model(snt.AbstractModule):\n \"\"\"Model for static cloth simulation.\"\"\"\n\n def __init__(self, learned_model, name='Model'):\n super(Model, self).__init__(name=name)\n with self._enter_variable_scope():\n self._learned_model = learned_model\n self._output_normalizer = normalization.Normalizer(\n size=3, name='output_normalizer')\n self._node_normalizer = normalization.Normalizer(\n size=3+common.NodeType.SIZE, name='node_normalizer')\n self._edge_normalizer = normalization.Normalizer(\n size=7, name='edge_normalizer') # 2D coord + 3D coord + 2*length = 7\n\n def _build_graph(self, inputs, is_training):\n \"\"\"Builds input graph.\"\"\"\n # construct graph nodes\n velocity = inputs['world_pos'] - inputs['prev|world_pos']\n node_type = tf.one_hot(inputs['node_type'][:, 0], common.NodeType.SIZE)\n node_features = tf.concat([velocity, node_type], axis=-1)\n\n # construct graph edges\n senders, receivers = common.triangles_to_edges(inputs['cells'])\n relative_world_pos = (tf.gather(inputs['world_pos'], senders) -\n tf.gather(inputs['world_pos'], receivers))\n relative_mesh_pos = (tf.gather(inputs['mesh_pos'], senders) -\n tf.gather(inputs['mesh_pos'], receivers))\n edge_features = tf.concat([\n relative_world_pos,\n tf.norm(relative_world_pos, axis=-1, keepdims=True),\n relative_mesh_pos,\n tf.norm(relative_mesh_pos, axis=-1, keepdims=True)], axis=-1)\n\n mesh_edges = core_model.EdgeSet(\n name='mesh_edges',\n features=self._edge_normalizer(edge_features, is_training),\n receivers=receivers,\n senders=senders)\n return core_model.MultiGraph(\n node_features=self._node_normalizer(node_features, is_training),\n edge_sets=[mesh_edges])\n\n def _build(self, inputs):\n graph = self._build_graph(inputs, is_training=False)\n per_node_network_output = self._learned_model(graph)\n return self._update(inputs, per_node_network_output)\n\n @snt.reuse_variables\n def loss(self, inputs):\n \"\"\"L2 loss on position.\"\"\"\n graph = self._build_graph(inputs, is_training=True)\n network_output = self._learned_model(graph)\n\n # build target acceleration\n cur_position = inputs['world_pos']\n prev_position = inputs['prev|world_pos']\n target_position = inputs['target|world_pos']\n target_acceleration = target_position - 2*cur_position + prev_position\n target_normalized = self._output_normalizer(target_acceleration)\n\n # build loss\n loss_mask = tf.equal(inputs['node_type'][:, 0], common.NodeType.NORMAL)\n error = tf.reduce_sum((target_normalized - network_output)**2, axis=1)\n loss = tf.reduce_mean(error[loss_mask])\n return loss\n\n def _update(self, inputs, per_node_network_output):\n \"\"\"Integrate model outputs.\"\"\"\n acceleration = self._output_normalizer.inverse(per_node_network_output)\n # integrate forward\n cur_position = inputs['world_pos']\n prev_position = inputs['prev|world_pos']\n position = 2*cur_position + acceleration - prev_position\n return position\n" ]

[ [ "tensorflow.compat.v1.concat", "tensorflow.compat.v1.equal", "tensorflow.compat.v1.reduce_mean", "tensorflow.compat.v1.reduce_sum", "tensorflow.compat.v1.one_hot", "tensorflow.compat.v1.gather", "tensorflow.compat.v1.norm" ] ]

TimK1998/SemanticSynthesisForScoreBasedModels

[ "b575ab646dd5a599d173b44a3585429082d0620d" ]

[ "configs/cityscapes256.py" ]

[ "import ml_collections\nimport torch\n\n\ndef get_default_configs():\n config = ml_collections.ConfigDict()\n\n # training\n config.training = training = ml_collections.ConfigDict()\n config.training.batch_size = 8\n training.epochs = 2000\n # Time in epochs\n training.checkpoint_save_freq = 50\n training.sampling_freq = 25\n # Time in steps\n training.log_freq = 50\n training.eval_freq = 5000\n training.snapshot_sampling = True\n training.reduce_mean = False\n\n # sampling\n config.sampling = sampling = ml_collections.ConfigDict()\n sampling.n_steps_each = 1\n sampling.noise_removal = True\n sampling.probability_flow = False\n sampling.snr = 0.1\n sampling.batch_size = 1\n sampling.sampling_height = 256\n sampling.sampling_width = 512\n sampling.sem_seg_scale = 0.02\n\n # data\n config.data = data = ml_collections.ConfigDict()\n data.dataset = 'cityscapes256'\n data.image_size = 256\n data.random_flip = False\n data.n_channels = 3\n data.n_labels = 20\n data.crop_to_square = False\n\n # model\n config.model = model = ml_collections.ConfigDict()\n model.sigma_min = 0.01\n model.sigma_max = 338\n model.n_scales = 2000\n model.beta_min = 0.1\n model.beta_max = 20.\n model.dropout = 0.\n model.embedding_type = 'fourier'\n model.bilinear = True\n model.conditional = True\n\n # optimization\n config.optim = optim = ml_collections.ConfigDict()\n optim.weight_decay = 0\n optim.lr = 2e-4\n optim.beta1 = 0.9\n optim.eps = 1e-8\n optim.warmup = 5000\n optim.grad_clip = 1.\n optim.mixed_prec = True\n\n config.device = torch.device('cuda:0') if torch.cuda.is_available() else torch.device('cpu')\n\n return config\n" ]

[ [ "torch.device", "torch.cuda.is_available" ] ]

DanLuoNEU/CLASP2

[ "262fb1f151c14bfe3b1c452cdf65187d8caa10bd" ]

[ "Visualizaion/hands_association.py" ]

[ "# Build up association between hands and persons ID, \n# depending on IOU between skeleton and person bounding boxes\n# Intersection part reference: https://github.com/amdegroot/ssd.pytorch/blob/master/layers/box_utils.py#L48\n# Points to improve: \n# 1. same hands for two persons using IOU, they should be unique\n# Dan, 09/29/2019\n########## Import ##########\nimport os\nimport cv2\nimport json\nimport pickle\nimport numpy as np\nimport scipy.io as sio\nfrom progress.bar import Bar\nfrom numpy.core.records import fromarrays\n########## Configuration ##########\nfile_people = 'CLASP-DATA-102419/cam09exp2_logs_fullv1.txt'\nfile_joints = 'data/joints_all_cam09exp2_102419.pkl'\nfile_save = 'data/hands_id_cam09exp2_102419.pkl'\n# Load Person Detection result{'bbox':,\n# 'id':,\n# 'bins':\n# }\n# persons_joints: dictionary\n# {- keys: frame\n# - values: dictionary {\n# ['image_name'],string of /path/to/image\n# ['people'],list of joints\n# }\n# }\n\ndef jaccard(box_a, boxes_b):\n \"\"\"Compute the jaccard overlap of one box and a list of boxes. \n The jaccard overlap is simply the intersection over union of two boxes. \n Here we operate on person box and skeleton boxes.\n E.g.:\n A n B / A U B = A n B / (area(A) + area(B) - A n B)\n Args:\n box_a: (list) Person bounding box, Shape: [4,]\n boxes_b: (list) Skeleton bounding boxes, Shape: [num_skeletons,4]\n Return:\n jaccard overlap: (tensor) Shape: [boxes_b.size(0)]\n \"\"\"\n b_a = np.asarray(box_a)[np.newaxis,:]\n b_b = np.asarray(boxes_b)\n num_a = b_a.shape[0]\n num_b = b_b.shape[0]\n min_xy_a = np.repeat(np.expand_dims(b_a[:,:2], 1),num_b,axis=1)\n min_xy_b = np.repeat(np.expand_dims(b_b[:,:2], 0),num_a,axis=0)\n max_xy_a = np.repeat(np.expand_dims(b_a[:,2:], 1),num_b,axis=1)\n max_xy_b = np.repeat(np.expand_dims(b_b[:,2:], 0),num_a,axis=0)\n min_xy = np.maximum(min_xy_a, min_xy_b) \n max_xy = np.minimum(max_xy_a, max_xy_b)\n \n inter_xy = np.clip((max_xy - min_xy), 0, np.inf)\n inter = inter_xy[:,:,0] * inter_xy[:,:,1]\n area_a = np.repeat(np.expand_dims(((b_a[:, 2]-b_a[:, 0]) * (b_a[:, 3]-b_a[:, 1])), 1),num_b,axis=1)\n area_b = np.repeat(np.expand_dims(((b_b[:, 2]-b_b[:, 0]) * (b_b[:, 3]-b_b[:, 1])), 0),num_a,axis=0)\n union = area_a + area_b - inter\n\n return (inter/union)[0,:]\n\n\ndef main():\n # Load persons data\n with open(file_people, 'r') as f:\n # frame, id, x1,y1,x2,y2\n lines = f.readlines()\n persons = {'id':{}, 'bbox':{},'bins':{},'hands':{}}\n for line in lines:\n splitted = line.split(',')\n frame_num = int(splitted[0])\n pid = splitted[1]\n x1 = int(splitted[2])\n y1 = int(splitted[3])\n x2 = int(splitted[4])\n y2 = int(splitted[5])\n\n if(frame_num not in persons['id'].keys()):\n persons['id'][frame_num] = []\n persons['bbox'][frame_num] = []\n persons['hands'][frame_num] = []\n persons['bins'][frame_num] = []\n\n persons['id'][frame_num].append(pid)\n persons['bbox'][frame_num].append([x1,y1,x2,y2])\n persons['hands'][frame_num].append([])\n persons['bins'][frame_num].append([])\n\n # # Load joints estimation results, .mat file\n # joints_mat = sio.loadmat(joints_path)\n # skeletons = joints_mat['people'][0]\n # Load joints estimation results, .pkl file\n with open( file_joints, 'rb') as f:\n persons_joints = pickle.load(f)\n\n # For every frame, for every person bbox, for every skeleton\n # compute IOU between person bbox and skeleton bbox\n # Attach hands info to persons data\n bar = Bar('Processing hands association:', max=len(persons['id']))\n for frame_id in persons['id'].keys():\n # Build bounding box for each skeleton\n # REMEMBER to filter the (0,0) joints\n bboxes_skeleton = []\n if len(persons_joints[frame_id]['people']) == 0:\n bar.next()\n continue\n for skeleton in persons_joints[frame_id]['people']:\n ## Avoid that (0,0) point is always the top left point\n for joint in skeleton:\n if joint[0] != 0 and joint[1] != 0:\n x_min, x_max = joint[0],joint[0] \n y_min, y_max = joint[1],joint[1]\n for joint in skeleton:\n if joint[0] != 0 and joint[1] != 0:\n if joint[0] < x_min: x_min = joint[0]\n elif joint[0] > x_max: x_max = joint[0]\n \n if joint[1] < y_min: y_min = joint[1]\n elif joint[1] > y_max: y_max = joint[1]\n bboxes_skeleton.append([int(x_min), int(y_min), int(x_max), int(y_max)])\n # Find the skeleton with largest IOU with the person bounding box\n for ind in range(len(persons['bbox'][frame_id])):\n bbox = persons['bbox'][frame_id][ind]\n # compute IOU\n IOUs = jaccard(bbox, bboxes_skeleton)\n skeleton_id = np.argmax(IOUs)\n if IOUs[skeleton_id] != 0:\n persons['hands'][frame_id][ind]=(persons_joints[frame_id]['people'][skeleton_id][[4,7]]).astype(int)\n bar.next()\n bar.finish()\n\n # # Test if hands in person bounding box \n # for frame_id in persons['id'].keys():\n # print(persons['hands'][frame_id],persons['bbox'][frame_id]) \n \n # Save using pickle, success\n with open(file_save,'wb') as f:\n pickle.dump(persons, f)\n\n # # Test if save the right file \n # with open(file_save,'r') as f:\n # persons = pickle.load(f) \n\n print(\"Well Done!\")\n\n\nif __name__ == \"__main__\":\n main()" ]

[ [ "numpy.expand_dims", "numpy.maximum", "numpy.minimum", "numpy.clip", "numpy.asarray", "numpy.argmax" ] ]

Bpowers4/turicreate

[ "73dad213cc1c4f74337b905baea2b3a1e5a0266c" ]

[ "src/python/turicreate/toolkits/drawing_classifier/_tf_drawing_classifier.py" ]

[ "# -*- coding: utf-8 -*-\n# Copyright © 2019 Apple Inc. All rights reserved.\n#\n# Use of this source code is governed by a BSD-3-clause license that can\n# be found in the LICENSE.txt file or at https://opensource.org/licenses/BSD-3-Clause\nfrom __future__ import print_function as _\nfrom __future__ import division as _\nfrom __future__ import absolute_import as _\n\nimport numpy as _np\nfrom .._tf_model import TensorFlowModel\nimport turicreate.toolkits._tf_utils as _utils\nimport tensorflow.compat.v1 as _tf\n\n# This toolkit is compatible with TensorFlow V2 behavior.\n# However, until all toolkits are compatible, we must call `disable_v2_behavior()`.\n_tf.disable_v2_behavior()\n\n\nclass DrawingClassifierTensorFlowModel(TensorFlowModel):\n def __init__(self, net_params, batch_size, num_classes):\n \"\"\"\n Defines the TensorFlow model, loss, optimisation and accuracy. Then\n loads the weights into the model.\n \"\"\"\n self.gpu_policy = _utils.TensorFlowGPUPolicy()\n self.gpu_policy.start()\n\n for key in net_params.keys():\n net_params[key] = _utils.convert_shared_float_array_to_numpy(\n net_params[key]\n )\n\n self.dc_graph = _tf.Graph()\n self.num_classes = num_classes\n self.batch_size = batch_size\n self.sess = _tf.Session(graph=self.dc_graph)\n with self.dc_graph.as_default():\n self.init_drawing_classifier_graph(net_params)\n\n def init_drawing_classifier_graph(self, net_params):\n\n self.input = _tf.placeholder(_tf.float32, [self.batch_size, 28, 28, 1])\n self.weights = _tf.placeholder(_tf.float32, [self.batch_size, 1])\n self.labels = _tf.placeholder(_tf.int64, [self.batch_size, 1])\n\n # One hot encoding target\n reshaped_labels = _tf.reshape(self.labels, [self.batch_size])\n one_hot_labels = _tf.one_hot(reshaped_labels, depth=self.num_classes, axis=-1)\n\n # Reshaping weights\n reshaped_weights = _tf.reshape(self.weights, [self.batch_size])\n\n self.one_hot_labels = _tf.placeholder(_tf.int32, [None, self.num_classes])\n\n # Weights\n weights = {\n name: _tf.Variable(\n _utils.convert_conv2d_coreml_to_tf(net_params[name]), name=name\n )\n for name in (\n \"drawing_conv0_weight\",\n \"drawing_conv1_weight\",\n \"drawing_conv2_weight\",\n )\n }\n weights[\"drawing_dense1_weight\"] = _tf.Variable(\n _utils.convert_dense_coreml_to_tf(net_params[\"drawing_dense1_weight\"]),\n name=\"drawing_dense1_weight\",\n )\n \"\"\"\n To make output of CoreML pool3 (NCHW) compatible with TF (NHWC).\n Decompose FC weights to NCHW. Transpose to NHWC. Reshape back to FC.\n \"\"\"\n coreml_128_576 = net_params[\"drawing_dense0_weight\"]\n coreml_128_576 = _np.reshape(coreml_128_576, (128, 64, 3, 3))\n coreml_128_576 = _np.transpose(coreml_128_576, (0, 2, 3, 1))\n coreml_128_576 = _np.reshape(coreml_128_576, (128, 576))\n weights[\"drawing_dense0_weight\"] = _tf.Variable(\n _np.transpose(coreml_128_576, (1, 0)), name=\"drawing_dense0_weight\"\n )\n\n # Biases\n biases = {\n name: _tf.Variable(net_params[name], name=name)\n for name in (\n \"drawing_conv0_bias\",\n \"drawing_conv1_bias\",\n \"drawing_conv2_bias\",\n \"drawing_dense0_bias\",\n \"drawing_dense1_bias\",\n )\n }\n\n conv_1 = _tf.nn.conv2d(\n self.input, weights[\"drawing_conv0_weight\"], strides=1, padding=\"SAME\"\n )\n conv_1 = _tf.nn.bias_add(conv_1, biases[\"drawing_conv0_bias\"])\n relu_1 = _tf.nn.relu(conv_1)\n pool_1 = _tf.nn.max_pool2d(\n relu_1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding=\"VALID\"\n )\n\n conv_2 = _tf.nn.conv2d(\n pool_1, weights[\"drawing_conv1_weight\"], strides=1, padding=\"SAME\"\n )\n conv_2 = _tf.nn.bias_add(conv_2, biases[\"drawing_conv1_bias\"])\n relu_2 = _tf.nn.relu(conv_2)\n pool_2 = _tf.nn.max_pool2d(\n relu_2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding=\"VALID\"\n )\n\n conv_3 = _tf.nn.conv2d(\n pool_2, weights[\"drawing_conv2_weight\"], strides=1, padding=\"SAME\"\n )\n conv_3 = _tf.nn.bias_add(conv_3, biases[\"drawing_conv2_bias\"])\n relu_3 = _tf.nn.relu(conv_3)\n pool_3 = _tf.nn.max_pool2d(\n relu_3, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding=\"VALID\"\n )\n\n # Flatten the data to a 1-D vector for the fully connected layer\n fc1 = _tf.reshape(pool_3, (-1, 576))\n fc1 = _tf.nn.xw_plus_b(\n fc1,\n weights=weights[\"drawing_dense0_weight\"],\n biases=biases[\"drawing_dense0_bias\"],\n )\n fc1 = _tf.nn.relu(fc1)\n\n out = _tf.nn.xw_plus_b(\n fc1,\n weights=weights[\"drawing_dense1_weight\"],\n biases=biases[\"drawing_dense1_bias\"],\n )\n self.predictions = _tf.nn.softmax(out)\n\n # Loss\n self.cost = _tf.losses.softmax_cross_entropy(\n logits=out,\n onehot_labels=one_hot_labels,\n weights=reshaped_weights,\n reduction=_tf.losses.Reduction.NONE,\n )\n\n # Optimizer\n self.optimizer = _tf.train.AdamOptimizer(learning_rate=0.001).minimize(\n self.cost\n )\n\n self.sess = _tf.Session()\n self.sess.run(_tf.global_variables_initializer())\n\n def __del__(self):\n self.sess.close()\n self.gpu_policy.stop()\n\n def train(self, feed_dict):\n\n for key in feed_dict.keys():\n feed_dict[key] = _utils.convert_shared_float_array_to_numpy(feed_dict[key])\n\n _, final_train_loss, final_train_output = self.sess.run(\n [self.optimizer, self.cost, self.predictions],\n feed_dict={\n self.input: feed_dict[\"input\"],\n self.labels: feed_dict[\"labels\"],\n self.weights: feed_dict[\"weights\"],\n },\n )\n\n result = {\n \"loss\": _np.array(final_train_loss),\n \"output\": _np.array(final_train_output),\n }\n\n return result\n\n def predict(self, feed_dict):\n\n is_train = \"labels\" in feed_dict\n\n for key in feed_dict.keys():\n feed_dict[key] = _utils.convert_shared_float_array_to_numpy(feed_dict[key])\n\n feed_dict_for_session = {self.input: feed_dict[\"input\"]}\n\n if is_train:\n\n feed_dict_for_session[self.labels] = feed_dict[\"labels\"]\n feed_dict_for_session[self.weights] = feed_dict[\"weights\"]\n\n pred_probs, loss = self.sess.run(\n [self.predictions, self.cost], feed_dict=feed_dict_for_session\n )\n\n result = {\"loss\": _np.array(loss), \"output\": _np.array(pred_probs)}\n else:\n pred_probs = self.sess.run(\n [self.predictions], feed_dict=feed_dict_for_session\n )\n result = {\"output\": _np.array(pred_probs)}\n\n return result\n\n def export_weights(self):\n \"\"\"\n Retrieve weights from the TF model, convert to the format Core ML\n expects and store in a dictionary.\n\n Returns\n -------\n net_params : dict\n Dictionary of weights, where the key is the name of the\n layer (e.g. `drawing_conv0_weight`) and the value is the\n respective weight of type `numpy.ndarray`.\n \"\"\"\n\n net_params = {}\n with self.dc_graph.as_default():\n layer_names = _tf.trainable_variables()\n layer_weights = self.sess.run(layer_names)\n\n for var, val in zip(layer_names, layer_weights):\n if \"bias\" in var.name:\n net_params.update({var.name.replace(\":0\", \"\"): val})\n else:\n if \"dense\" in var.name:\n if \"drawing_dense0_weight\" in var.name:\n \"\"\"\n To make output of TF pool3 (NHWC) compatible with CoreML (NCHW).\n Decompose FC weights to NHWC. Transpose to NCHW. Reshape back to FC.\n \"\"\"\n tf_576_128 = val\n tf_576_128 = _np.reshape(tf_576_128, (3, 3, 64, 128))\n tf_576_128 = _np.transpose(tf_576_128, (2, 0, 1, 3))\n tf_576_128 = _np.reshape(tf_576_128, (576, 128))\n net_params.update(\n {\n var.name.replace(\":0\", \"\"): _np.transpose(\n tf_576_128, (1, 0)\n )\n }\n )\n else:\n net_params.update(\n {var.name.replace(\":0\", \"\"): val.transpose(1, 0)}\n )\n else:\n # np.transpose won't change the underlying memory layout\n # but in turicreate we will force it.\n net_params.update(\n {\n var.name.replace(\n \":0\", \"\"\n ): _utils.convert_conv2d_tf_to_coreml(val)\n }\n )\n\n return net_params\n" ]

[ [ "tensorflow.compat.v1.nn.max_pool2d", "tensorflow.compat.v1.train.AdamOptimizer", "numpy.reshape", "tensorflow.compat.v1.reshape", "tensorflow.compat.v1.trainable_variables", "tensorflow.compat.v1.one_hot", "tensorflow.compat.v1.nn.softmax", "tensorflow.compat.v1.nn.conv2d", "tensorflow.compat.v1.Graph", "tensorflow.compat.v1.nn.relu", "tensorflow.compat.v1.losses.softmax_cross_entropy", "numpy.transpose", "numpy.array", "tensorflow.compat.v1.Variable", "tensorflow.compat.v1.disable_v2_behavior", "tensorflow.compat.v1.nn.xw_plus_b", "tensorflow.compat.v1.global_variables_initializer", "tensorflow.compat.v1.Session", "tensorflow.compat.v1.placeholder", "tensorflow.compat.v1.nn.bias_add" ] ]

dgbirm/elo_sailor

[ "0978eac23e9334eee8cab3225840f82fbc153194" ]

[ "ISAFlaserResults/code/csvClean.py" ]

[ "#Scrap code for cleaning the CSV files so that we can read them easier\n\nimport csv\nimport sys\nimport pandas as pd\nimport numpy as np\nimport os\nimport re\n\nfrom selenium import webdriver\nfrom time import sleep\nfrom text_unidecode import unidecode\nfrom tabulate import tabulate\n\nsys.path.append('/home/daniel/Desktop/elo_sailor/Glicko2approach')\nfrom SailingGlicko2 import *\nfrom Scrape import *\n\nos.chdir(\"..\")\n\ndef getHiddenHTML(currentRegatta):\n browser = webdriver.Firefox()\n browser.get(currentRegatta)\n sleep(2)\n innerHTML = browser.execute_script(\"return document.getElementsByTagName('html')[0].innerHTML\")\n browser.close()\n return innerHTML\n\ncolorlst=[('0000ff', '2'), ('0000ff', '21'), ('bbbb00', '4'), ('bbbb00', '4'), ('bbbb00', '3'), ('bbbb00', '4'), ('999900', '8'), ('999900', '2'), ('999900', '5'), ('999900', '13'), ('999900', '14'), ('999900', '51'), ('0000ff', '2'), ('0000ff', '21'), ('bbbb00', '4'), ('bbbb00', '4'), ('bbbb00', '3'), ('bbbb00', '4'), ('999900', '8'), ('999900', '2'), ('999900', '5'), ('999900', '13'), ('999900', '14'), ('999900', '51'), ('ff0000', '13'), ('ff0000', '7'), ('ff0000', '3'), ('ff0000', '1'), ('0000ff', '2'), ('0000ff', '1'), ('999900', '19'), ('999900', '18'), ('999900', '30'), ('999900', '1'), ('999900', '6'), ('999900', '5'), ('ff0000', '13'), ('ff0000', '7'), ('ff0000', '3'), ('ff0000', '1'), ('0000ff', '2'), ('0000ff', '1'), ('999900', '19'), ('999900', '18'), ('999900', '30'), ('999900', '1'), ('999900', '6'), ('999900', '5'), ('ff0000', '2'), ('ff0000', '2'), ('0000ff', '3'), ('0000ff', '7'), ('ff0000', '4'), ('ff0000', '53 UFD'), ('999900', '4'), ('999900', '38'), ('999900', '13'), ('999900', '23'), ('999900', '2'), ('999900', '9'), ('ff0000', '2'), ('ff0000', '2'), ('0000ff', '3'), ('0000ff', '7'), ('ff0000', '4'), ('ff0000', '53 UFD'), ('999900', '4'), ('999900', '38'), ('999900', '13'), ('999900', '23'), ('999900', '2'), ('999900', '9'), ('0000ff', '12'), ('0000ff', '7'), ('bbbb00', '2'), ('bbbb00', '2'), ('ff0000', '1'), ('ff0000', '1'), ('999900', '17'), ('999900', '8'), ('999900', '39'), ('999900', '21'), ('999900', '1'), ('999900', '12'), ('0000ff', '12'), ('0000ff', '7'), ('bbbb00', '2'), ('bbbb00', '2'), ('ff0000', '1'), ('ff0000', '1'), ('999900', '17'), ('999900', '8'), ('999900', '39'), ('999900', '21'), ('999900', '1'), ('999900', '12'), ('ff0000', '17'), ('ff0000', '4'), ('0000ff', '9'), ('0000ff', '9'), ('bbbb00', '2'), ('bbbb00', '5'), ('999900', '23'), ('999900', '7'), ('999900', '7'), ('999900', '22'), ('999900', '4'), ('999900', '4'), ('ff0000', '17'), ('ff0000', '4'), ('0000ff', '9'), ('0000ff', '9'), ('bbbb00', '2'), ('bbbb00', '5'), ('999900', '23'), ('999900', '7'), ('999900', '7'), ('999900', '22'), ('999900', '4'), ('999900', '4'), ('0000ff', '3'), ('0000ff', '2'), ('ff0000', '7'), ('ff0000', '2'), ('0000ff', '1'), ('0000ff', '7'), ('999900', '22'), ('999900', '22'), ('999900', '2'), ('999900', '11'), ('999900', '8'), ('999900', '20'), ('0000ff', '3'), ('0000ff', '2'), ('ff0000', '7'), ('ff0000', '2'), ('0000ff', '1'), ('0000ff', '7'), ('999900', '22'), ('999900', '22'), ('999900', '2'), ('999900', '11'), ('999900', '8'), ('999900', '20'), ('bbbb00', '5'), ('bbbb00', '13'), ('0000ff', '5'), ('0000ff', '4'), ('bbbb00', '1'), ('bbbb00', '1'), ('999900', '24'), ('999900', '40'), ('999900', '29'), ('999900', '4'), ('999900', '9'), ('999900', '10'), ('bbbb00', '5'), ('bbbb00', '13'), ('0000ff', '5'), ('0000ff', '4'), ('bbbb00', '1'), ('bbbb00', '1'), ('999900', '24'), ('999900', '40'), ('999900', '29'), ('999900', '4'), ('999900', '9'), ('999900', '10'), ('ff0000', '5'), ('ff0000', '6'), ('bbbb00', '12'), ('bbbb00', '14'), ('ff0000', '15'), ('ff0000', '7'), ('999900', '16'), ('999900', '6'), ('999900', '12'), ('999900', '7'), ('999900', '45'), ('999900', '7'), ('ff0000', '5'), ('ff0000', '6'), ('bbbb00', '12'), ('bbbb00', '14'), ('ff0000', '15'), ('ff0000', '7'), ('999900', '16'), ('999900', '6'), ('999900', '12'), ('999900', '7'), ('999900', '45'), ('999900', '7'), ('bbbb00', '6'), ('bbbb00', '10'), ('ff0000', '2'), ('ff0000', '5'), ('0000ff', '7'), ('0000ff', '3'), ('999900', '7'), ('999900', '14'), ('999900', '31'), ('999900', '10'), ('999900', '53 BFD'), ('999900', '11'), ('bbbb00', '6'), ('bbbb00', '10'), ('ff0000', '2'), ('ff0000', '5'), ('0000ff', '7'), ('0000ff', '3'), ('999900', '7'), ('999900', '14'), ('999900', '31'), ('999900', '10'), ('999900', '53 BFD'), ('999900', '11'), ('bbbb00', '21'), ('bbbb00', '5'), ('ff0000', '10'), ('ff0000', '7'), ('0000ff', '3'), ('0000ff', '4'), ('999900', '15'), ('999900', '11'), ('999900', '18'), ('999900', '6'), ('999900', '32'), ('999900', '17'), ('bbbb00', '21'), ('bbbb00', '5'), ('ff0000', '10'), ('ff0000', '7'), ('0000ff', '3'), ('0000ff', '4'), ('999900', '15'), ('999900', '11'), ('999900', '18'), ('999900', '6'), ('999900', '32'), ('999900', '17'), ('ff0000', '15'), ('ff0000', '18'), ('ff0000', '6'), ('ff0000', '6'), ('ff0000', '2'), ('ff0000', '4'), ('999900', '35'), ('999900', '15'), ('999900', '3'), ('999900', '2'), ('999900', '18'), ('999900', '34'), ('ff0000', '15'), ('ff0000', '18'), ('ff0000', '6'), ('ff0000', '6'), ('ff0000', '2'), ('ff0000', '4'), ('999900', '35'), ('999900', '15'), ('999900', '3'), ('999900', '2'), ('999900', '18'), ('999900', '34'), ('0000ff', '27'), ('0000ff', '3'), ('0000ff', '4'), ('0000ff', '3'), ('bbbb00', '5'), ('bbbb00', '2'), ('999900', '14'), ('999900', '30'), ('999900', '15'), ('999900', '25'), ('999900', '21'), ('999900', '32'), ('0000ff', '27'), ('0000ff', '3'), ('0000ff', '4'), ('0000ff', '3'), ('bbbb00', '5'), ('bbbb00', '2'), ('999900', '14'), ('999900', '30'), ('999900', '15'), ('999900', '25'), ('999900', '21'), ('999900', '32'), ('ff0000', '8'), ('ff0000', '3'), ('bbbb00', '3'), ('bbbb00', '1'), ('bbbb00', '8'), ('bbbb00', '8'), ('999900', '22 SCP'), ('999900', '27'), ('999900', '28'), ('999900', '12'), ('999900', '33'), ('999900', '13'), ('ff0000', '8'), ('ff0000', '3'), ('bbbb00', '3'), ('bbbb00', '1'), ('bbbb00', '8'), ('bbbb00', '8'), ('999900', '22 SCP'), ('999900', '27'), ('999900', '28'), ('999900', '12'), ('999900', '33'), ('999900', '13'), ('0000ff', '6'), ('0000ff', '17'), ('bbbb00', '15'), ('bbbb00', '15'), ('0000ff', '14'), ('0000ff', '17'), ('999900', '3'), ('999900', '3'), ('999900', '20'), ('999900', '37'), ('999900', '17'), ('999900', '19'), ('0000ff', '6'), ('0000ff', '17'), ('bbbb00', '15'), ('bbbb00', '15'), ('0000ff', '14'), ('0000ff', '17'), ('999900', '3'), ('999900', '3'), ('999900', '20'), ('999900', '37'), ('999900', '17'), ('999900', '19'), ('bbbb00', '4'), ('bbbb00', '4'), ('ff0000', '1'), ('ff0000', '8'), ('0000ff', '13'), ('0000ff', '10'), ('999900', '49'), ('999900', '45'), ('999900', '35'), ('999900', '9'), ('999900', '15'), ('999900', '2'), ('bbbb00', '4'), ('bbbb00', '4'), ('ff0000', '1'), ('ff0000', '8'), ('0000ff', '13'), ('0000ff', '10'), ('999900', '49'), ('999900', '45'), ('999900', '35'), ('999900', '9'), ('999900', '15'), ('999900', '2'), ('0000ff', '16'), ('0000ff', '12'), ('0000ff', '2'), ('0000ff', '1'), ('bbbb00', '4'), ('bbbb00', '3'), ('999900', '27'), ('999900', '21'), ('999900', '33'), ('999900', '29'), ('999900', '29'), ('999900', '6'), ('0000ff', '16'), ('0000ff', '12'), ('0000ff', '2'), ('0000ff', '1'), ('bbbb00', '4'), ('bbbb00', '3'), ('999900', '27'), ('999900', '21'), ('999900', '33'), ('999900', '29'), ('999900', '29'), ('999900', '6'), ('ff0000', '14'), ('ff0000', '1'), ('bbbb00', '8'), ('bbbb00', '3'), ('ff0000', '9'), ('ff0000', '9'), ('999900', '1'), ('999900', '46'), ('999900', '41'), ('999900', '33'), ('999900', '30'), ('999900', '3'), ('ff0000', '14'), ('ff0000', '1'), ('bbbb00', '8'), ('bbbb00', '3'), ('ff0000', '9'), ('ff0000', '9'), ('999900', '1'), ('999900', '46'), ('999900', '41'), ('999900', '33'), ('999900', '30'), ('999900', '3'), ('ff0000', '18'), ('ff0000', '53 BFD'), ('ff0000', '4'), ('ff0000', '9'), ('bbbb00', '6'), ('bbbb00', '7'), ('999900', '53 UFD'), ('999900', '34'), ('999900', '10'), ('999900', '15'), ('999900', '22'), ('999900', '15'), ('ff0000', '18'), ('ff0000', '53 BFD'), ('ff0000', '4'), ('ff0000', '9'), ('bbbb00', '6'), ('bbbb00', '7'), ('999900', '53 UFD'), ('999900', '34'), ('999900', '10'), ('999900', '15'), ('999900', '22'), ('999900', '15'), ('0000ff', '5'), ('0000ff', '20'), ('0000ff', '1'), ('0000ff', '16'), ('bbbb00', '15'), ('bbbb00', '10'), ('999900', '36'), ('999900', '9'), ('999900', '4'), ('999900', '3'), ('999900', '42'), ('999900', '43'), ('0000ff', '5'), ('0000ff', '20'), ('0000ff', '1'), ('0000ff', '16'), ('bbbb00', '15'), ('bbbb00', '10'), ('999900', '36'), ('999900', '9'), ('999900', '4'), ('999900', '3'), ('999900', '42'), ('999900', '43'), ('bbbb00', '9'), ('bbbb00', '2'), ('0000ff', '10'), ('0000ff', '8'), ('ff0000', '23'), ('ff0000', '13'), ('999900', '11'), ('999900', '44'), ('999900', '19'), ('999900', '14'), ('999900', '20'), ('999900', '39'), ('bbbb00', '9'), ('bbbb00', '2'), ('0000ff', '10'), ('0000ff', '8'), ('ff0000', '23'), ('ff0000', '13'), ('999900', '11'), ('999900', '44'), ('999900', '19'), ('999900', '14'), ('999900', '20'), ('999900', '39'), ('bbbb00', '37'), ('bbbb00', '53 BFD'), ('bbbb00', '1'), ('bbbb00', '5'), ('0000ff', '6'), ('0000ff', '5'), ('999900', '26'), ('999900', '26'), ('999900', '32'), ('999900', '20'), ('999900', '12'), ('999900', '16'), ('bbbb00', '37'), ('bbbb00', '53 BFD'), ('bbbb00', '1'), ('bbbb00', '5'), ('0000ff', '6'), ('0000ff', '5'), ('999900', '26'), ('999900', '26'), ('999900', '32'), ('999900', '20'), ('999900', '12'), ('999900', '16'), ('bbbb00', '7'), ('bbbb00', '7'), ('0000ff', '53 BFD'), ('0000ff', '6'), ('0000ff', '11'), ('0000ff', '11'), ('999900', '30'), ('999900', '29'), ('999900', '9'), ('999900', '26'), ('999900', '16'), ('999900', '31'), ('bbbb00', '7'), ('bbbb00', '7'), ('0000ff', '53 BFD'), ('0000ff', '6'), ('0000ff', '11'), ('0000ff', '11'), ('999900', '30'), ('999900', '29'), ('999900', '9'), ('999900', '26'), ('999900', '16'), ('999900', '31'), ('0000ff', '14'), ('0000ff', '16'), ('ff0000', '16'), ('ff0000', '10'), ('0000ff', '15'), ('0000ff', '2'), ('999900', '18'), ('999900', '42'), ('999900', '47'), ('999900', '17'), ('999900', '13'), ('999900', '8'), ('0000ff', '14'), ('0000ff', '16'), ('ff0000', '16'), ('ff0000', '10'), ('0000ff', '15'), ('0000ff', '2'), ('999900', '18'), ('999900', '42'), ('999900', '47'), ('999900', '17'), ('999900', '13'), ('999900', '8'), ('bbbb00', '1'), ('bbbb00', '3'), ('bbbb00', '17'), ('bbbb00', '12'), ('0000ff', '9'), ('0000ff', '6'), ('999900', '9'), ('999900', '37'), ('999900', '8'), ('999900', '34'), ('999900', '49'), ('999900', '40'), ('bbbb00', '1'), ('bbbb00', '3'), ('bbbb00', '17'), ('bbbb00', '12'), ('0000ff', '9'), ('0000ff', '6'), ('999900', '9'), ('999900', '37'), ('999900', '8'), ('999900', '34'), ('999900', '49'), ('999900', '40'), ('0000ff', '30'), ('0000ff', '26'), ('0000ff', '7'), ('0000ff', '15'), ('ff0000', '3'), ('ff0000', '6'), ('999900', '32'), ('999900', '43'), ('999900', '42'), ('999900', '18'), ('999900', '10'), ('999900', '1'), ('0000ff', '30'), ('0000ff', '26'), ('0000ff', '7'), ('0000ff', '15'), ('ff0000', '3'), ('ff0000', '6'), ('999900', '32'), ('999900', '43'), ('999900', '42'), ('999900', '18'), ('999900', '10'), ('999900', '1'), ('ff0000', '20'), ('ff0000', '17'), ('0000ff', '11'), ('0000ff', '19'), ('bbbb00', '17'), ('bbbb00', '11'), ('999900', '10'), ('999900', '23'), ('999900', '22'), ('999900', '31'), ('999900', '3'), ('999900', '33'), ('ff0000', '20'), ('ff0000', '17'), ('0000ff', '11'), ('0000ff', '19'), ('bbbb00', '17'), ('bbbb00', '11'), ('999900', '10'), ('999900', '23'), ('999900', '22'), ('999900', '31'), ('999900', '3'), ('999900', '33'), ('ff0000', '9'), ('ff0000', '25'), ('0000ff', '14'), ('0000ff', '5'), ('0000ff', '21'), ('0000ff', '19'), ('999900', '29'), ('999900', '10'), ('999900', '21'), ('999900', '8'), ('999900', '37'), ('999900', '38'), ('ff0000', '9'), ('ff0000', '25'), ('0000ff', '14'), ('0000ff', '5'), ('0000ff', '21'), ('0000ff', '19'), ('999900', '29'), ('999900', '10'), ('999900', '21'), ('999900', '8'), ('999900', '37'), ('999900', '38'), ('ff0000', '32'), ('ff0000', '16'), ('0000ff', '16'), ('0000ff', '17'), ('0000ff', '5'), ('0000ff', '8'), ('999900', '5'), ('999900', '48'), ('999900', '1'), ('999900', '40'), ('999900', '53 BFD'), ('999900', '18'), ('ff0000', '32'), ('ff0000', '16'), ('0000ff', '16'), ('0000ff', '17'), ('0000ff', '5'), ('0000ff', '8'), ('999900', '5'), ('999900', '48'), ('999900', '1'), ('999900', '40'), ('999900', '53 BFD'), ('999900', '18'), ('0000ff', '8'), ('0000ff', '6'), ('ff0000', '22'), ('ff0000', '14'), ('bbbb00', '12'), ('bbbb00', '21'), ('999900', '37'), ('999900', '33'), ('999900', '14'), ('999900', '5'), ('999900', '27'), ('999900', '47'), ('0000ff', '8'), ('0000ff', '6'), ('ff0000', '22'), ('ff0000', '14'), ('bbbb00', '12'), ('bbbb00', '21'), ('999900', '37'), ('999900', '33'), ('999900', '14'), ('999900', '5'), ('999900', '27'), ('999900', '47'), ('bbbb00', '2'), ('bbbb00', '28'), ('bbbb00', '13'), ('bbbb00', '9'), ('0000ff', '18'), ('0000ff', '18'), ('999900', '34'), ('999900', '13'), ('999900', '50'), ('999900', '32'), ('999900', '34'), ('999900', '14'), ('bbbb00', '2'), ('bbbb00', '28'), ('bbbb00', '13'), ('bbbb00', '9'), ('0000ff', '18'), ('0000ff', '18'), ('999900', '34'), ('999900', '13'), ('999900', '50'), ('999900', '32'), ('999900', '34'), ('999900', '14'), ('ff0000', '35'), ('ff0000', '5'), ('0000ff', '17'), ('0000ff', '11'), ('ff0000', '7'), ('ff0000', '23'), ('999900', '13'), ('999900', '35'), ('999900', '17'), ('999900', '35 SCP'), ('999900', '26'), ('999900', '36'), ('ff0000', '35'), ('ff0000', '5'), ('0000ff', '17'), ('0000ff', '11'), ('ff0000', '7'), ('ff0000', '23'), ('999900', '13'), ('999900', '35'), ('999900', '17'), ('999900', '35 SCP'), ('999900', '26'), ('999900', '36'), ('ff0000', '19'), ('ff0000', '14'), ('ff0000', '13'), ('ff0000', '21'), ('bbbb00', '21'), ('bbbb00', '6'), ('999900', '44'), ('999900', '28'), ('999900', '6'), ('999900', '16'), ('999900', '28'), ('999900', '45'), ('ff0000', '19'), ('ff0000', '14'), ('ff0000', '13'), ('ff0000', '21'), ('bbbb00', '21'), ('bbbb00', '6'), ('999900', '44'), ('999900', '28'), ('999900', '6'), ('999900', '16'), ('999900', '28'), ('999900', '45'), ('ff0000', '23'), ('ff0000', '24'), ('0000ff', '12'), ('0000ff', '12'), ('0000ff', '8'), ('0000ff', '20'), ('999900', '12'), ('999900', '24'), ('999900', '37'), ('999900', '42'), ('999900', '7'), ('999900', '41'), ('ff0000', '23'), ('ff0000', '24'), ('0000ff', '12'), ('0000ff', '12'), ('0000ff', '8'), ('0000ff', '20'), ('999900', '12'), ('999900', '24'), ('999900', '37'), ('999900', '42'), ('999900', '7'), ('999900', '41'), ('ff0000', '26'), ('ff0000', '12'), ('bbbb00', '11'), ('bbbb00', '10'), ('ff0000', '12'), ('ff0000', '8'), ('999900', '21'), ('999900', '21 SCP'), ('999900', '44'), ('999900', '50'), ('999900', '31'), ('999900', '26'), ('ff0000', '26'), ('ff0000', '12'), ('bbbb00', '11'), ('bbbb00', '10'), ('ff0000', '12'), ('ff0000', '8'), ('999900', '21'), ('999900', '21 SCP'), ('999900', '44'), ('999900', '50'), ('999900', '31'), ('999900', '26'), ('0000ff', '4'), ('0000ff', '15'), ('bbbb00', '7'), ('bbbb00', '7'), ('ff0000', '17'), ('ff0000', '3'), ('999900', '2'), ('999900', '52'), ('999900', '34'), ('999900', '48'), ('999900', '40'), ('999900', '37'), ('0000ff', '4'), ('0000ff', '15'), ('bbbb00', '7'), ('bbbb00', '7'), ('ff0000', '17'), ('ff0000', '3'), ('999900', '2'), ('999900', '52'), ('999900', '34'), ('999900', '48'), ('999900', '40'), ('999900', '37'), ('0000ff', '9'), ('0000ff', '22'), ('ff0000', '11'), ('ff0000', '4'), ('bbbb00', '7'), ('bbbb00', '9'), ('999900', '40'), ('999900', '19'), ('999900', '38'), ('999900', '41'), ('999900', '38'), ('999900', '24'), ('0000ff', '9'), ('0000ff', '22'), ('ff0000', '11'), ('ff0000', '4'), ('bbbb00', '7'), ('bbbb00', '9'), ('999900', '40'), ('999900', '19'), ('999900', '38'), ('999900', '41'), ('999900', '38'), ('999900', '24'), ('0000ff', '36'), ('0000ff', '9'), ('0000ff', '13'), ('0000ff', '21'), ('ff0000', '20'), ('ff0000', '5'), ('999900', '39'), ('999900', '32'), ('999900', '16'), ('999900', '35'), ('999900', '11'), ('999900', '50'), ('0000ff', '36'), ('0000ff', '9'), ('0000ff', '13'), ('0000ff', '21'), ('ff0000', '20'), ('ff0000', '5'), ('999900', '39'), ('999900', '32'), ('999900', '16'), ('999900', '35'), ('999900', '11'), ('999900', '50'), ('ff0000', '29'), ('ff0000', '13'), ('0000ff', '53 BFD'), ('0000ff', '10'), ('0000ff', '12'), ('0000ff', '16'), ('999900', '48'), ('999900', '31'), ('999900', '25'), ('999900', '30'), ('999900', '5'), ('999900', '30'), ('ff0000', '29'), ('ff0000', '13'), ('0000ff', '53 BFD'), ('0000ff', '10'), ('0000ff', '12'), ('0000ff', '16'), ('999900', '48'), ('999900', '31'), ('999900', '25'), ('999900', '30'), ('999900', '5'), ('999900', '30'), ('0000ff', '1'), ('0000ff', '19'), ('0000ff', '6'), ('0000ff', '25'), ('0000ff', '20'), ('0000ff', '35'), ('999900', '45'), ('999900', '12'), ('999900', '11'), ('999900', '28'), ('999900', '47'), ('999900', '35'), ('0000ff', '1'), ('0000ff', '19'), ('0000ff', '6'), ('0000ff', '25'), ('0000ff', '20'), ('0000ff', '35'), ('999900', '45'), ('999900', '12'), ('999900', '11'), ('999900', '28'), ('999900', '47'), ('999900', '35'), ('0000ff', '24'), ('0000ff', '30'), ('bbbb00', '10'), ('bbbb00', '11'), ('ff0000', '18'), ('ff0000', '17'), ('999900', '42'), ('999900', '1'), ('999900', '27'), ('999900', '38'), ('999900', '41'), ('999900', '21'), ('0000ff', '24'), ('0000ff', '30'), ('bbbb00', '10'), ('bbbb00', '11'), ('ff0000', '18'), ('ff0000', '17'), ('999900', '42'), ('999900', '1'), ('999900', '27'), ('999900', '38'), ('999900', '41'), ('999900', '21'), ('0000ff', '34'), ('0000ff', '25'), ('0000ff', '8'), ('0000ff', '20'), ('ff0000', '10'), ('ff0000', '11'), ('999900', '28'), ('999900', '20'), ('999900', '43'), ('999900', '44'), ('999900', '24'), ('999900', '28'), ('0000ff', '34'), ('0000ff', '25'), ('0000ff', '8'), ('0000ff', '20'), ('ff0000', '10'), ('ff0000', '11'), ('999900', '28'), ('999900', '20'), ('999900', '43'), ('999900', '44'), ('999900', '24'), ('999900', '28'), ('bbbb00', '13'), ('bbbb00', '1'), ('ff0000', '5'), ('ff0000', '3'), ('ff0000', '8'), ('ff0000', '2'), ('999900', '53 UFD'), ('999900', '36'), ('999900', '23'), ('999900', '52'), ('999900', '44'), ('999900', '44'), ('bbbb00', '13'), ('bbbb00', '1'), ('ff0000', '5'), ('ff0000', '3'), ('ff0000', '8'), ('ff0000', '2'), ('999900', '53 UFD'), ('999900', '36'), ('999900', '23'), ('999900', '52'), ('999900', '44'), ('999900', '44'), ('0000ff', '28'), ('0000ff', '1'), ('bbbb00', '6'), ('bbbb00', '16'), ('ff0000', '29'), ('ff0000', '10'), ('999900', '41'), ('999900', '25'), ('999900', '40'), ('999900', '39'), ('999900', '25'), ('999900', '29'), ('0000ff', '28'), ('0000ff', '1'), ('bbbb00', '6'), ('bbbb00', '16'), ('ff0000', '29'), ('ff0000', '10'), ('999900', '41'), ('999900', '25'), ('999900', '40'), ('999900', '39'), ('999900', '25'), ('999900', '29'), ('bbbb00', '12'), ('bbbb00', '53 BFD'), ('ff0000', '14'), ('ff0000', '19'), ('0000ff', '4'), ('0000ff', '14'), ('999900', '20'), ('999900', '41'), ('999900', '24'), ('999900', '43'), ('999900', '36'), ('999900', '53'), ('bbbb00', '12'), ('bbbb00', '53 BFD'), ('ff0000', '14'), ('ff0000', '19'), ('0000ff', '4'), ('0000ff', '14'), ('999900', '20'), ('999900', '41'), ('999900', '24'), ('999900', '43'), ('999900', '36'), ('999900', '53'), ('ff0000', '1'), ('ff0000', '11'), ('0000ff', '15'), ('0000ff', '24'), ('ff0000', '26'), ('ff0000', '22'), ('999900', '33'), ('999900', '4'), ('999900', '51'), ('999900', '45'), ('999900', '53 BFD'), ('999900', '25'), ('ff0000', '1'), ('ff0000', '11'), ('0000ff', '15'), ('0000ff', '24'), ('ff0000', '26'), ('ff0000', '22'), ('999900', '33'), ('999900', '4'), ('999900', '51'), ('999900', '45'), ('999900', '53 BFD'), ('999900', '25'), ('0000ff', '11'), ('0000ff', '4'), ('bbbb00', '25'), ('bbbb00', '17'), ('0000ff', '25'), ('0000ff', '27'), ('999900', '43'), ('999900', '16'), ('999900', '26'), ('999900', '46'), ('999900', '23'), ('999900', '42'), ('0000ff', '11'), ('0000ff', '4'), ('bbbb00', '25'), ('bbbb00', '17'), ('0000ff', '25'), ('0000ff', '27'), ('999900', '43'), ('999900', '16'), ('999900', '26'), ('999900', '46'), ('999900', '23'), ('999900', '42'), ('bbbb00', '27'), ('bbbb00', '14'), ('ff0000', '9'), ('ff0000', '17'), ('ff0000', '13'), ('ff0000', '15'), ('999900', '25'), ('999900', '51'), ('999900', '48'), ('999900', '27'), ('999900', '48'), ('999900', '27'), ('bbbb00', '27'), ('bbbb00', '14'), ('ff0000', '9'), ('ff0000', '17'), ('ff0000', '13'), ('ff0000', '15'), ('999900', '25'), ('999900', '51'), ('999900', '48'), ('999900', '27'), ('999900', '48'), ('999900', '27'), ('ff0000', '6'), ('ff0000', '9'), ('0000ff', '27'), ('0000ff', '22'), ('bbbb00', '36'), ('bbbb00', '16'), ('999900', '50'), ('999900', '50'), ('999900', '36'), ('999900', '24'), ('999900', '35'), ('999900', '23'), ('ff0000', '6'), ('ff0000', '9'), ('0000ff', '27'), ('0000ff', '22'), ('bbbb00', '36'), ('bbbb00', '16'), ('999900', '50'), ('999900', '50'), ('999900', '36'), ('999900', '24'), ('999900', '35'), ('999900', '23'), ('ff0000', '30'), ('ff0000', '10'), ('bbbb00', '9'), ('bbbb00', '18'), ('bbbb00', '23'), ('bbbb00', '15'), ('999900', '47'), ('999900', '17'), ('999900', '49'), ('999900', '49'), ('999900', '19'), ('999900', '49'), ('ff0000', '30'), ('ff0000', '10'), ('bbbb00', '9'), ('bbbb00', '18'), ('bbbb00', '23'), ('bbbb00', '15'), ('999900', '47'), ('999900', '17'), ('999900', '49'), ('999900', '49'), ('999900', '19'), ('999900', '49'), ('ff0000', '12'), ('ff0000', '28'), ('bbbb00', '5'), ('bbbb00', '8'), ('bbbb00', '25'), ('bbbb00', '12'), ('999900', '38'), ('999900', '39'), ('999900', '45'), ('999900', '36'), ('999900', '43'), ('999900', '46'), ('ff0000', '12'), ('ff0000', '28'), ('bbbb00', '5'), ('bbbb00', '8'), ('bbbb00', '25'), ('bbbb00', '12'), ('999900', '38'), ('999900', '39'), ('999900', '45'), ('999900', '36'), ('999900', '43'), ('999900', '46'), ('ff0000', '3'), ('ff0000', '53 BFD'), ('ff0000', '17'), ('ff0000', '22'), ('bbbb00', '14'), ('bbbb00', '13'), ('999900', '31'), ('999900', '49'), ('999900', '53 UFD'), ('999900', '51'), ('999900', '46'), ('999900', '22'), ('ff0000', '3'), ('ff0000', '53 BFD'), ('ff0000', '17'), ('ff0000', '22'), ('bbbb00', '14'), ('bbbb00', '13'), ('999900', '31'), ('999900', '49'), ('999900', '53 UFD'), ('999900', '51'), ('999900', '46'), ('999900', '22'), ('bbbb00', '20'), ('bbbb00', '12'), ('bbbb00', '20'), ('bbbb00', '6'), ('0000ff', '27'), ('0000ff', '9'), ('999900', '46'), ('999900', '47'), ('999900', '46'), ('999900', '47'), ('999900', '39'), ('999900', '48'), ('bbbb00', '20'), ('bbbb00', '12'), ('bbbb00', '20'), ('bbbb00', '6'), ('0000ff', '27'), ('0000ff', '9'), ('999900', '46'), ('999900', '47'), ('999900', '46'), ('999900', '47'), ('999900', '39'), ('999900', '48'), ('0000ff', '19'), ('0000ff', '8'), ('ff0000', '27'), ('ff0000', '15'), ('bbbb00', '30'), ('bbbb00', '18'), ('999999', '1'), ('999999', '2'), ('999999', '15'), ('999999', '6'), ('999999', '15'), ('999999', '13'), ('0000ff', '19'), ('0000ff', '8'), ('ff0000', '27'), ('ff0000', '15'), ('bbbb00', '30'), ('bbbb00', '18'), ('999999', '1'), ('999999', '2'), ('999999', '15'), ('999999', '6'), ('999999', '15'), ('999999', '13'), ('bbbb00', '14'), ('bbbb00', '24'), ('0000ff', '23'), ('0000ff', '35'), ('bbbb00', '11'), ('bbbb00', '30'), ('999999', '3'), ('999999', '3'), ('999999', '13'), ('999999', '1'), ('999999', '7'), ('999999', '16'), ('bbbb00', '14'), ('bbbb00', '24'), ('0000ff', '23'), ('0000ff', '35'), ('bbbb00', '11'), ('bbbb00', '30'), ('999999', '3'), ('999999', '3'), ('999999', '13'), ('999999', '1'), ('999999', '7'), ('999999', '16'), ('bbbb00', '17'), ('bbbb00', '53 BFD'), ('bbbb00', '24'), ('bbbb00', '30'), ('0000ff', '19'), ('0000ff', '22'), ('999999', '25'), ('999999', '7'), ('999999', '6'), ('999999', '8'), ('999999', '9'), ('999999', '17'), ('bbbb00', '17'), ('bbbb00', '53 BFD'), ('bbbb00', '24'), ('bbbb00', '30'), ('0000ff', '19'), ('0000ff', '22'), ('999999', '25'), ('999999', '7'), ('999999', '6'), ('999999', '8'), ('999999', '9'), ('999999', '17'), ('0000ff', '44'), ('0000ff', '18'), ('ff0000', '12'), ('ff0000', '53 UFD'), ('ff0000', '6'), ('ff0000', '30'), ('999999', '19'), ('999999', '19'), ('999999', '2'), ('999999', '7'), ('999999', '5'), ('999999', '44'), ('0000ff', '44'), ('0000ff', '18'), ('ff0000', '12'), ('ff0000', '53 UFD'), ('ff0000', '6'), ('ff0000', '30'), ('999999', '19'), ('999999', '19'), ('999999', '2'), ('999999', '7'), ('999999', '5'), ('999999', '44'), ('ff0000', '46'), ('ff0000', '8'), ('ff0000', '32'), ('ff0000', '11'), ('bbbb00', '9'), ('bbbb00', '24'), ('999999', '13'), ('999999', '28'), ('999999', '37'), ('999999', '24'), ('999999', '13'), ('999999', '1'), ('ff0000', '46'), ('ff0000', '8'), ('ff0000', '32'), ('ff0000', '11'), ('bbbb00', '9'), ('bbbb00', '24'), ('999999', '13'), ('999999', '28'), ('999999', '37'), ('999999', '24'), ('999999', '13'), ('999999', '1'), ('ff0000', '7'), ('ff0000', '27'), ('bbbb00', '21'), ('bbbb00', '22'), ('bbbb00', '10'), ('bbbb00', '29'), ('999999', '53 BFD'), ('999999', '33'), ('999999', '1'), ('999999', '37'), ('999999', '11'), ('999999', '3'), ('ff0000', '7'), ('ff0000', '27'), ('bbbb00', '21'), ('bbbb00', '22'), ('bbbb00', '10'), ('bbbb00', '29'), ('999999', '53 BFD'), ('999999', '33'), ('999999', '1'), ('999999', '37'), ('999999', '11'), ('999999', '3'), ('bbbb00', '8'), ('bbbb00', '29'), ('ff0000', '19'), ('ff0000', '32'), ('ff0000', '28'), ('ff0000', '21'), ('999999', '21'), ('999999', '6'), ('999999', '30'), ('999999', '9'), ('999999', '12'), ('999999', '20'), ('bbbb00', '8'), ('bbbb00', '29'), ('ff0000', '19'), ('ff0000', '32'), ('ff0000', '28'), ('ff0000', '21'), ('999999', '21'), ('999999', '6'), ('999999', '30'), ('999999', '9'), ('999999', '12'), ('999999', '20'), ('0000ff', '40'), ('0000ff', '34'), ('0000ff', '53 BFD'), ('0000ff', '2'), ('bbbb00', '18'), ('bbbb00', '32'), ('999999', '6'), ('999999', '30'), ('999999', '7'), ('999999', '14'), ('999999', '20'), ('999999', '11'), ('0000ff', '40'), ('0000ff', '34'), ('0000ff', '53 BFD'), ('0000ff', '2'), ('bbbb00', '18'), ('bbbb00', '32'), ('999999', '6'), ('999999', '30'), ('999999', '7'), ('999999', '14'), ('999999', '20'), ('999999', '11'), ('0000ff', '43'), ('0000ff', '13'), ('ff0000', '21'), ('ff0000', '23'), ('bbbb00', '22'), ('bbbb00', '25'), ('999999', '9'), ('999999', '22'), ('999999', '12'), ('999999', '16'), ('999999', '17'), ('999999', '21'), ('0000ff', '43'), ('0000ff', '13'), ('ff0000', '21'), ('ff0000', '23'), ('bbbb00', '22'), ('bbbb00', '25'), ('999999', '9'), ('999999', '22'), ('999999', '12'), ('999999', '16'), ('999999', '17'), ('999999', '21'), ('0000ff', '7'), ('0000ff', '32'), ('ff0000', '30'), ('ff0000', '18'), ('bbbb00', '13'), ('bbbb00', '33'), ('999999', '16'), ('999999', '10'), ('999999', '5'), ('999999', '42'), ('999999', '53 BFD'), ('999999', '8'), ('0000ff', '7'), ('0000ff', '32'), ('ff0000', '30'), ('ff0000', '18'), ('bbbb00', '13'), ('bbbb00', '33'), ('999999', '16'), ('999999', '10'), ('999999', '5'), ('999999', '42'), ('999999', '53 BFD'), ('999999', '8'), ('bbbb00', '29'), ('bbbb00', '31'), ('0000ff', '31'), ('0000ff', '29'), ('ff0000', '24'), ('ff0000', '19'), ('999999', '36'), ('999999', '4'), ('999999', '25'), ('999999', '29'), ('999999', '1'), ('999999', '4'), ('bbbb00', '29'), ('bbbb00', '31'), ('0000ff', '31'), ('0000ff', '29'), ('ff0000', '24'), ('ff0000', '19'), ('999999', '36'), ('999999', '4'), ('999999', '25'), ('999999', '29'), ('999999', '1'), ('999999', '4'), ('bbbb00', '28'), ('bbbb00', '53 BFD'), ('ff0000', '8'), ('ff0000', '27'), ('ff0000', '19'), ('ff0000', '31'), ('999999', '18'), ('999999', '24'), ('999999', '33'), ('999999', '26'), ('999999', '2'), ('999999', '15'), ('bbbb00', '28'), ('bbbb00', '53 BFD'), ('ff0000', '8'), ('ff0000', '27'), ('ff0000', '19'), ('ff0000', '31'), ('999999', '18'), ('999999', '24'), ('999999', '33'), ('999999', '26'), ('999999', '2'), ('999999', '15'), ('ff0000', '40'), ('ff0000', '19'), ('ff0000', '20'), ('ff0000', '29'), ('0000ff', '35'), ('0000ff', '42'), ('999999', '20'), ('999999', '13'), ('999999', '10'), ('999999', '22'), ('999999', '4'), ('999999', '26'), ('ff0000', '40'), ('ff0000', '19'), ('ff0000', '20'), ('ff0000', '29'), ('0000ff', '35'), ('0000ff', '42'), ('999999', '20'), ('999999', '13'), ('999999', '10'), ('999999', '22'), ('999999', '4'), ('999999', '26'), ('ff0000', '10'), ('ff0000', '23'), ('0000ff', '22'), ('0000ff', '34'), ('bbbb00', '37'), ('bbbb00', '17'), ('999999', '14'), ('999999', '17'), ('999999', '18'), ('999999', '15'), ('999999', '32'), ('999999', '30'), ('ff0000', '10'), ('ff0000', '23'), ('0000ff', '22'), ('0000ff', '34'), ('bbbb00', '37'), ('bbbb00', '17'), ('999999', '14'), ('999999', '17'), ('999999', '18'), ('999999', '15'), ('999999', '32'), ('999999', '30'), ('0000ff', '37'), ('0000ff', '11'), ('bbbb00', '26'), ('bbbb00', '29'), ('ff0000', '36'), ('ff0000', '27'), ('999999', '44'), ('999999', '18'), ('999999', '3'), ('999999', '19'), ('999999', '3'), ('999999', '27'), ('0000ff', '37'), ('0000ff', '11'), ('bbbb00', '26'), ('bbbb00', '29'), ('ff0000', '36'), ('ff0000', '27'), ('999999', '44'), ('999999', '18'), ('999999', '3'), ('999999', '19'), ('999999', '3'), ('999999', '27'), ('ff0000', '24'), ('ff0000', '15'), ('ff0000', '26'), ('ff0000', '34'), ('bbbb00', '19'), ('bbbb00', '31'), ('999999', '22'), ('999999', '39'), ('999999', '35'), ('999999', '2'), ('999999', '14'), ('999999', '12'), ('ff0000', '24'), ('ff0000', '15'), ('ff0000', '26'), ('ff0000', '34'), ('bbbb00', '19'), ('bbbb00', '31'), ('999999', '22'), ('999999', '39'), ('999999', '35'), ('999999', '2'), ('999999', '14'), ('999999', '12'), ('0000ff', '32'), ('0000ff', '31'), ('0000ff', '53 BFD'), ('0000ff', '23'), ('0000ff', '17'), ('0000ff', '21'), ('999999', '31'), ('999999', '8'), ('999999', '4'), ('999999', '27'), ('999999', '22'), ('999999', '18'), ('0000ff', '32'), ('0000ff', '31'), ('0000ff', '53 BFD'), ('0000ff', '23'), ('0000ff', '17'), ('0000ff', '21'), ('999999', '31'), ('999999', '8'), ('999999', '4'), ('999999', '27'), ('999999', '22'), ('999999', '18'), ('bbbb00', '11'), ('bbbb00', '6'), ('ff0000', '23'), ('ff0000', '33'), ('ff0000', '25'), ('ff0000', '20'), ('999999', '2'), ('999999', '43'), ('999999', '34'), ('999999', '36'), ('999999', '8'), ('999999', '40'), ('bbbb00', '11'), ('bbbb00', '6'), ('ff0000', '23'), ('ff0000', '33'), ('ff0000', '25'), ('ff0000', '20'), ('999999', '2'), ('999999', '43'), ('999999', '34'), ('999999', '36'), ('999999', '8'), ('999999', '40'), ('bbbb00', '24'), ('bbbb00', '32'), ('bbbb00', '27'), ('bbbb00', '19'), ('0000ff', '26'), ('0000ff', '30'), ('999999', '29'), ('999999', '15'), ('999999', '19'), ('999999', '12'), ('999999', '33'), ('999999', '5'), ('bbbb00', '24'), ('bbbb00', '32'), ('bbbb00', '27'), ('bbbb00', '19'), ('0000ff', '26'), ('0000ff', '30'), ('999999', '29'), ('999999', '15'), ('999999', '19'), ('999999', '12'), ('999999', '33'), ('999999', '5'), ('0000ff', '29'), ('0000ff', '5'), ('bbbb00', '32'), ('bbbb00', '34'), ('0000ff', '44'), ('0000ff', '32'), ('999999', '5'), ('999999', '1'), ('999999', '11'), ('999999', '32'), ('999999', '26'), ('999999', '38'), ('0000ff', '29'), ('0000ff', '5'), ('bbbb00', '32'), ('bbbb00', '34'), ('0000ff', '44'), ('0000ff', '32'), ('999999', '5'), ('999999', '1'), ('999999', '11'), ('999999', '32'), ('999999', '26'), ('999999', '38'), ('0000ff', '25'), ('0000ff', '38'), ('bbbb00', '28'), ('bbbb00', '24'), ('0000ff', '31'), ('0000ff', '28'), ('999999', '15'), ('999999', '20'), ('999999', '21'), ('999999', '39'), ('999999', '6'), ('999999', '10'), ('0000ff', '25'), ('0000ff', '38'), ('bbbb00', '28'), ('bbbb00', '24'), ('0000ff', '31'), ('0000ff', '28'), ('999999', '15'), ('999999', '20'), ('999999', '21'), ('999999', '39'), ('999999', '6'), ('999999', '10'), ('0000ff', '22'), ('0000ff', '28'), ('bbbb00', '14'), ('bbbb00', '20'), ('ff0000', '11'), ('ff0000', '16'), ('999999', '10'), ('999999', '27'), ('999999', '26'), ('999999', '44'), ('999999', '53 BFD'), ('999999', '19'), ('0000ff', '22'), ('0000ff', '28'), ('bbbb00', '14'), ('bbbb00', '20'), ('ff0000', '11'), ('ff0000', '16'), ('999999', '10'), ('999999', '27'), ('999999', '26'), ('999999', '44'), ('999999', '53 BFD'), ('999999', '19'), ('bbbb00', '34'), ('bbbb00', '20'), ('0000ff', '24'), ('0000ff', '26'), ('ff0000', '27'), ('ff0000', '26'), ('999999', '38'), ('999999', '5'), ('999999', '14'), ('999999', '13'), ('999999', '21'), ('999999', '34'), ('bbbb00', '34'), ('bbbb00', '20'), ('0000ff', '24'), ('0000ff', '26'), ('ff0000', '27'), ('ff0000', '26'), ('999999', '38'), ('999999', '5'), ('999999', '14'), ('999999', '13'), ('999999', '21'), ('999999', '34'), ('ff0000', '36'), ('ff0000', '21'), ('ff0000', '15'), ('ff0000', '13'), ('ff0000', '5'), ('ff0000', '28'), ('999999', '4'), ('999999', '40'), ('999999', '48'), ('999999', '5'), ('999999', '53 RET'), ('999999', '32'), ('ff0000', '36'), ('ff0000', '21'), ('ff0000', '15'), ('ff0000', '13'), ('ff0000', '5'), ('ff0000', '28'), ('999999', '4'), ('999999', '40'), ('999999', '48'), ('999999', '5'), ('999999', '53 RET'), ('999999', '32'), ('ff0000', '11'), ('ff0000', '26'), ('ff0000', '46'), ('ff0000', '16'), ('ff0000', '35'), ('ff0000', '53 UFD'), ('999999', '12'), ('999999', '46'), ('999999', '31'), ('999999', '18'), ('999999', '16'), ('999999', '2'), ('ff0000', '11'), ('ff0000', '26'), ('ff0000', '46'), ('ff0000', '16'), ('ff0000', '35'), ('ff0000', '53 UFD'), ('999999', '12'), ('999999', '46'), ('999999', '31'), ('999999', '18'), ('999999', '16'), ('999999', '2'), ('bbbb00', '41'), ('bbbb00', '8'), ('ff0000', '31'), ('ff0000', '38.6 DPI'), ('0000ff', '24'), ('0000ff', '12'), ('999999', '17'), ('999999', '16'), ('999999', '17'), ('999999', '28'), ('999999', '53 RET'), ('999999', '22'), ('bbbb00', '41'), ('bbbb00', '8'), ('ff0000', '31'), ('ff0000', '38.6 DPI'), ('0000ff', '24'), ('0000ff', '12'), ('999999', '17'), ('999999', '16'), ('999999', '17'), ('999999', '28'), ('999999', '53 RET'), ('999999', '22'), ('ff0000', '31'), ('ff0000', '29'), ('bbbb00', '18'), ('bbbb00', '21'), ('ff0000', '31'), ('ff0000', '25'), ('999999', '27'), ('999999', '25'), ('999999', '16'), ('999999', '33'), ('999999', '23'), ('999999', '7'), ('ff0000', '31'), ('ff0000', '29'), ('bbbb00', '18'), ('bbbb00', '21'), ('ff0000', '31'), ('ff0000', '25'), ('999999', '27'), ('999999', '25'), ('999999', '16'), ('999999', '33'), ('999999', '23'), ('999999', '7'), ('0000ff', '41'), ('0000ff', '43'), ('0000ff', '19'), ('0000ff', '13'), ('ff0000', '14'), ('ff0000', '14'), ('999999', '39'), ('999999', '14'), ('999999', '9'), ('999999', '50'), ('999999', '28'), ('999999', '33'), ('0000ff', '41'), ('0000ff', '43'), ('0000ff', '19'), ('0000ff', '13'), ('ff0000', '14'), ('ff0000', '14'), ('999999', '39'), ('999999', '14'), ('999999', '9'), ('999999', '50'), ('999999', '28'), ('999999', '33'), ('0000ff', '20'), ('0000ff', '35'), ('bbbb00', '16'), ('bbbb00', '25'), ('0000ff', '22'), ('0000ff', '29'), ('999999', '11'), ('999999', '12'), ('999999', '38'), ('999999', '17'), ('999999', '53 BFD'), ('999999', '35'), ('0000ff', '20'), ('0000ff', '35'), ('bbbb00', '16'), ('bbbb00', '25'), ('0000ff', '22'), ('0000ff', '29'), ('999999', '11'), ('999999', '12'), ('999999', '38'), ('999999', '17'), ('999999', '53 BFD'), ('999999', '35'), ('0000ff', '26'), ('0000ff', '29'), ('0000ff', '53 BFD'), ('0000ff', '14'), ('bbbb00', '24'), ('bbbb00', '20'), ('999999', '33'), ('999999', '35'), ('999999', '8'), ('999999', '35'), ('999999', '19'), ('999999', '24'), ('0000ff', '26'), ('0000ff', '29'), ('0000ff', '53 BFD'), ('0000ff', '14'), ('bbbb00', '24'), ('bbbb00', '20'), ('999999', '33'), ('999999', '35'), ('999999', '8'), ('999999', '35'), ('999999', '19'), ('999999', '24'), ('0000ff', '38'), ('0000ff', '27'), ('ff0000', '18'), ('ff0000', '26'), ('bbbb00', '32'), ('bbbb00', '22'), ('999999', '32'), ('999999', '21'), ('999999', '24'), ('999999', '23'), ('999999', '10'), ('999999', '39'), ('0000ff', '38'), ('0000ff', '27'), ('ff0000', '18'), ('ff0000', '26'), ('bbbb00', '32'), ('bbbb00', '22'), ('999999', '32'), ('999999', '21'), ('999999', '24'), ('999999', '23'), ('999999', '10'), ('999999', '39'), ('0000ff', '33'), ('0000ff', '23'), ('bbbb00', '29'), ('bbbb00', '38'), ('bbbb00', '28'), ('bbbb00', '26'), ('999999', '28'), ('999999', '26'), ('999999', '29'), ('999999', '4'), ('999999', '25'), ('999999', '31'), ('0000ff', '33'), ('0000ff', '23'), ('bbbb00', '29'), ('bbbb00', '38'), ('bbbb00', '28'), ('bbbb00', '26'), ('999999', '28'), ('999999', '26'), ('999999', '29'), ('999999', '4'), ('999999', '25'), ('999999', '31'), ('bbbb00', '23'), ('bbbb00', '21'), ('bbbb00', '19'), ('bbbb00', '28'), ('bbbb00', '26'), ('bbbb00', '14'), ('999999', '53 BFD'), ('999999', '53 BFD'), ('999999', '23'), ('999999', '11'), ('999999', '18'), ('999999', '43'), ('bbbb00', '23'), ('bbbb00', '21'), ('bbbb00', '19'), ('bbbb00', '28'), ('bbbb00', '26'), ('bbbb00', '14'), ('999999', '53 BFD'), ('999999', '53 BFD'), ('999999', '23'), ('999999', '11'), ('999999', '18'), ('999999', '43'), ('bbbb00', '16'), ('bbbb00', '53 BFD'), ('ff0000', '25'), ('ff0000', '40'), ('ff0000', '21'), ('ff0000', '24'), ('999999', '8'), ('999999', '37'), ('999999', '46'), ('999999', '34'), ('999999', '53 BFD'), ('999999', '6'), ('bbbb00', '16'), ('bbbb00', '53 BFD'), ('ff0000', '25'), ('ff0000', '40'), ('ff0000', '21'), ('ff0000', '24'), ('999999', '8'), ('999999', '37'), ('999999', '46'), ('999999', '34'), ('999999', '53 BFD'), ('999999', '6'), ('ff0000', '27'), ('ff0000', '20'), ('ff0000', '33'), ('ff0000', '24'), ('bbbb00', '16'), ('bbbb00', '23'), ('999999', '26'), ('999999', '32'), ('999999', '41'), ('999999', '46'), ('999999', '30'), ('999999', '29'), ('ff0000', '27'), ('ff0000', '20'), ('ff0000', '33'), ('ff0000', '24'), ('bbbb00', '16'), ('bbbb00', '23'), ('999999', '26'), ('999999', '32'), ('999999', '41'), ('999999', '46'), ('999999', '30'), ('999999', '29'), ('bbbb00', '3'), ('bbbb00', '18'), ('ff0000', '43'), ('ff0000', '37.6 DPI'), ('0000ff', '40'), ('0000ff', '31'), ('999999', '37'), ('999999', '11'), ('999999', '28'), ('999999', '41'), ('999999', '29'), ('999999', '36'), ('bbbb00', '3'), ('bbbb00', '18'), ('ff0000', '43'), ('ff0000', '37.6 DPI'), ('0000ff', '40'), ('0000ff', '31'), ('999999', '37'), ('999999', '11'), ('999999', '28'), ('999999', '41'), ('999999', '29'), ('999999', '36'), ('0000ff', '18'), ('0000ff', '14'), ('bbbb00', '30'), ('bbbb00', '32'), ('ff0000', '40'), ('ff0000', '38'), ('999999', '7'), ('999999', '34'), ('999999', '22'), ('999999', '40'), ('999999', '37'), ('999999', '50'), ('0000ff', '18'), ('0000ff', '14'), ('bbbb00', '30'), ('bbbb00', '32'), ('ff0000', '40'), ('ff0000', '38'), ('999999', '7'), ('999999', '34'), ('999999', '22'), ('999999', '40'), ('999999', '37'), ('999999', '50'), ('ff0000', '47'), ('ff0000', '53 BFD'), ('ff0000', '28'), ('ff0000', '28'), ('0000ff', '29'), ('0000ff', '13'), ('999999', '24'), ('999999', '41'), ('999999', '47'), ('999999', '30'), ('999999', '40'), ('999999', '9'), ('ff0000', '47'), ('ff0000', '53 BFD'), ('ff0000', '28'), ('ff0000', '28'), ('0000ff', '29'), ('0000ff', '13'), ('999999', '24'), ('999999', '41'), ('999999', '47'), ('999999', '30'), ('999999', '40'), ('999999', '9'), ('bbbb00', '35'), ('bbbb00', '15'), ('0000ff', '20'), ('0000ff', '18'), ('0000ff', '36'), ('0000ff', '25'), ('999999', '53 RET'), ('999999', '45'), ('999999', '42'), ('999999', '3'), ('999999', '53 BFD'), ('999999', '41'), ('bbbb00', '35'), ('bbbb00', '15'), ('0000ff', '20'), ('0000ff', '18'), ('0000ff', '36'), ('0000ff', '25'), ('999999', '53 RET'), ('999999', '45'), ('999999', '42'), ('999999', '3'), ('999999', '53 BFD'), ('999999', '41'), ('ff0000', '51'), ('ff0000', '22'), ('0000ff', '25'), ('0000ff', '30'), ('ff0000', '16'), ('ff0000', '12'), ('999999', '43'), ('999999', '44'), ('999999', '32'), ('999999', '43'), ('999999', '36'), ('999999', '46'), ('ff0000', '51'), ('ff0000', '22'), ('0000ff', '25'), ('0000ff', '30'), ('ff0000', '16'), ('ff0000', '12'), ('999999', '43'), ('999999', '44'), ('999999', '32'), ('999999', '43'), ('999999', '36'), ('999999', '46'), ('bbbb00', '45'), ('bbbb00', '23'), ('ff0000', '24'), ('ff0000', '30'), ('ff0000', '30'), ('ff0000', '18'), ('999999', '41'), ('999999', '38'), ('999999', '39'), ('999999', '47'), ('999999', '53 BFD'), ('999999', '14'), ('bbbb00', '45'), ('bbbb00', '23'), ('ff0000', '24'), ('ff0000', '30'), ('ff0000', '30'), ('ff0000', '18'), ('999999', '41'), ('999999', '38'), ('999999', '39'), ('999999', '47'), ('999999', '53 BFD'), ('999999', '14'), ('0000ff', '15'), ('0000ff', '53 BFD'), ('0000ff', '35'), ('0000ff', '27'), ('0000ff', '34'), ('0000ff', '37'), ('999999', '23'), ('999999', '53 BFD'), ('999999', '27'), ('999999', '31'), ('999999', '53 BFD'), ('999999', '25'), ('0000ff', '15'), ('0000ff', '53 BFD'), ('0000ff', '35'), ('0000ff', '27'), ('0000ff', '34'), ('0000ff', '37'), ('999999', '23'), ('999999', '53 BFD'), ('999999', '27'), ('999999', '31'), ('999999', '53 BFD'), ('999999', '25'), ('0000ff', '21'), ('0000ff', '10'), ('0000ff', '26'), ('0000ff', '28'), ('0000ff', '38'), ('0000ff', '40'), ('999999', '34'), ('999999', '53 BFD'), ('999999', '49'), ('999999', '25'), ('999999', '35'), ('999999', '49'), ('0000ff', '21'), ('0000ff', '10'), ('0000ff', '26'), ('0000ff', '28'), ('0000ff', '38'), ('0000ff', '40'), ('999999', '34'), ('999999', '53 BFD'), ('999999', '49'), ('999999', '25'), ('999999', '35'), ('999999', '49'), ('0000ff', '23'), ('0000ff', '24'), ('bbbb00', '23'), ('bbbb00', '39'), ('ff0000', '37'), ('ff0000', '40'), ('999999', '40'), ('999999', '53 BFD'), ('999999', '36'), ('999999', '21'), ('999999', '24'), ('999999', '48'), ('0000ff', '23'), ('0000ff', '24'), ('bbbb00', '23'), ('bbbb00', '39'), ('ff0000', '37'), ('ff0000', '40'), ('999999', '40'), ('999999', '53 BFD'), ('999999', '36'), ('999999', '21'), ('999999', '24'), ('999999', '48'), ('bbbb00', '19'), ('bbbb00', '25'), ('bbbb00', '36'), ('bbbb00', '37'), ('0000ff', '30'), ('0000ff', '44'), ('999999', '30'), ('999999', '31'), ('999999', '40'), ('999999', '45'), ('999999', '31'), ('999999', '37'), ('bbbb00', '19'), ('bbbb00', '25'), ('bbbb00', '36'), ('bbbb00', '37'), ('0000ff', '30'), ('0000ff', '44'), ('999999', '30'), ('999999', '31'), ('999999', '40'), ('999999', '45'), ('999999', '31'), ('999999', '37'), ('bbbb00', '30'), ('bbbb00', '11'), ('0000ff', '53 BFD'), ('0000ff', '36'), ('bbbb00', '31'), ('bbbb00', '39'), ('999999', '53 BFD'), ('999999', '29'), ('999999', '53 RET'), ('999999', '20'), ('999999', '27'), ('999999', '42'), ('bbbb00', '30'), ('bbbb00', '11'), ('0000ff', '53 BFD'), ('0000ff', '36'), ('bbbb00', '31'), ('bbbb00', '39'), ('999999', '53 BFD'), ('999999', '29'), ('999999', '53 RET'), ('999999', '20'), ('999999', '27'), ('999999', '42'), ('ff0000', '21'), ('ff0000', '53 BFD'), ('bbbb00', '35'), ('bbbb00', '23'), ('bbbb00', '42'), ('bbbb00', '27'), ('999999', '42'), ('999999', '36'), ('999999', '45'), ('999999', '10'), ('999999', '39'), ('999999', '47'), ('ff0000', '21'), ('ff0000', '53 BFD'), ('bbbb00', '35'), ('bbbb00', '23'), ('bbbb00', '42'), ('bbbb00', '27'), ('999999', '42'), ('999999', '36'), ('999999', '45'), ('999999', '10'), ('999999', '39'), ('999999', '47'), ('bbbb00', '18'), ('bbbb00', '19'), ('bbbb00', '34'), ('bbbb00', '33'), ('bbbb00', '29'), ('bbbb00', '37'), ('999999', '53 RET'), ('999999', '53 BFD'), ('999999', '20'), ('999999', '49'), ('999999', '38'), ('999999', '28'), ('bbbb00', '18'), ('bbbb00', '19'), ('bbbb00', '34'), ('bbbb00', '33'), ('bbbb00', '29'), ('bbbb00', '37'), ('999999', '53 RET'), ('999999', '53 BFD'), ('999999', '20'), ('999999', '49'), ('999999', '38'), ('999999', '28'), ('bbbb00', '48'), ('bbbb00', '37'), ('ff0000', '40'), ('ff0000', '12'), ('bbbb00', '20'), ('bbbb00', '35'), ('999999', '53 BFD'), ('999999', '23'), ('999999', '43'), ('999999', '48'), ('999999', '53 BFD'), ('999999', '23'), ('bbbb00', '48'), ('bbbb00', '37'), ('ff0000', '40'), ('ff0000', '12'), ('bbbb00', '20'), ('bbbb00', '35'), ('999999', '53 BFD'), ('999999', '23'), ('999999', '43'), ('999999', '48'), ('999999', '53 BFD'), ('999999', '23'), ('bbbb00', '26'), ('bbbb00', '27'), ('ff0000', '38'), ('ff0000', '42'), ('bbbb00', '27'), ('bbbb00', '28'), ('999999', '53 BFD'), ('999999', '9'), ('999999', '44'), ('999999', '51'), ('999999', '34'), ('999999', '51'), ('bbbb00', '26'), ('bbbb00', '27'), ('ff0000', '38'), ('ff0000', '42'), ('bbbb00', '27'), ('bbbb00', '28'), ('999999', '53 BFD'), ('999999', '9'), ('999999', '44'), ('999999', '51'), ('999999', '34'), ('999999', '51'), ('0000ff', '17'), ('0000ff', '33'), ('bbbb00', '41'), ('bbbb00', '13'), ('0000ff', '10'), ('0000ff', '15'), ('999999', '53 DNC'), ('999999', '53 DNC'), ('999999', '53 DNC'), ('999999', '53 DNC'), ('999999', '53 DNC'), ('999999', '53'), ('0000ff', '17'), ('0000ff', '33'), ('bbbb00', '41'), ('bbbb00', '13'), ('0000ff', '10'), ('0000ff', '15'), ('999999', '53 DNC'), ('999999', '53 DNC'), ('999999', '53 DNC'), ('999999', '53 DNC'), ('999999', '53 DNC'), ('999999', '53'), ('bbbb00', '31'), ('bbbb00', '35'), ('bbbb00', '33'), ('bbbb00', '26'), ('0000ff', '28'), ('0000ff', '23'), ('999999', '35'), ('999999', '42'), ('999999', '53 UFD'), ('999999', '38'), ('999999', '53 RET'), ('999999', '45'), ('bbbb00', '31'), ('bbbb00', '35'), ('bbbb00', '33'), ('bbbb00', '26'), ('0000ff', '28'), ('0000ff', '23'), ('999999', '35'), ('999999', '42'), ('999999', '53 UFD'), ('999999', '38'), ('999999', '53 RET'), ('999999', '45'), ('ff0000', '33'), ('ff0000', '53 BFD'), ('bbbb00', '22'), ('bbbb00', '31'), ('ff0000', '34'), ('ff0000', '29'), ('8b4513', '9'), ('8b4513', '21'), ('8b4513', '3'), ('8b4513', '9'), ('8b4513', '1'), ('8b4513', '2'), ('ff0000', '33'), ('ff0000', '53 BFD'), ('bbbb00', '22'), ('bbbb00', '31'), ('ff0000', '34'), ('ff0000', '29'), ('8b4513', '9'), ('8b4513', '21'), ('8b4513', '3'), ('8b4513', '9'), ('8b4513', '1'), ('8b4513', '2'), ('bbbb00', '38'), ('bbbb00', '9'), ('ff0000', '42'), ('ff0000', '37'), ('bbbb00', '38'), ('bbbb00', '41'), ('8b4513', '7'), ('8b4513', '28'), ('8b4513', '1'), ('8b4513', '3'), ('8b4513', '2'), ('8b4513', '8'), ('bbbb00', '38'), ('bbbb00', '9'), ('ff0000', '42'), ('ff0000', '37'), ('bbbb00', '38'), ('bbbb00', '41'), ('8b4513', '7'), ('8b4513', '28'), ('8b4513', '1'), ('8b4513', '3'), ('8b4513', '2'), ('8b4513', '8'), ('ff0000', '16'), ('ff0000', '53 BFD'), ('0000ff', '34'), ('0000ff', '31'), ('ff0000', '32'), ('ff0000', '42'), ('8b4513', '8'), ('8b4513', '6'), ('8b4513', '4'), ('8b4513', '25'), ('8b4513', '12'), ('8b4513', '16'), ('ff0000', '16'), ('ff0000', '53 BFD'), ('0000ff', '34'), ('0000ff', '31'), ('ff0000', '32'), ('ff0000', '42'), ('8b4513', '8'), ('8b4513', '6'), ('8b4513', '4'), ('8b4513', '25'), ('8b4513', '12'), ('8b4513', '16'), ('ff0000', '22'), ('ff0000', '53 BFD'), ('ff0000', '36'), ('ff0000', '31'), ('ff0000', '33'), ('ff0000', '32'), ('8b4513', '17'), ('8b4513', '4'), ('8b4513', '2'), ('8b4513', '26'), ('8b4513', '16'), ('8b4513', '7'), ('ff0000', '22'), ('ff0000', '53 BFD'), ('ff0000', '36'), ('ff0000', '31'), ('ff0000', '33'), ('ff0000', '32'), ('8b4513', '17'), ('8b4513', '4'), ('8b4513', '2'), ('8b4513', '26'), ('8b4513', '16'), ('8b4513', '7'), ('bbbb00', '36'), ('bbbb00', '53 BFD'), ('0000ff', '18'), ('0000ff', '32'), ('ff0000', '39'), ('ff0000', '34'), ('8b4513', '3'), ('8b4513', '49'), ('8b4513', '26'), ('8b4513', '6'), ('8b4513', '6'), ('8b4513', '1'), ('bbbb00', '36'), ('bbbb00', '53 BFD'), ('0000ff', '18'), ('0000ff', '32'), ('ff0000', '39'), ('ff0000', '34'), ('8b4513', '3'), ('8b4513', '49'), ('8b4513', '26'), ('8b4513', '6'), ('8b4513', '6'), ('8b4513', '1'), ('bbbb00', '25'), ('bbbb00', '34'), ('bbbb00', '31'), ('bbbb00', '27'), ('0000ff', '33'), ('0000ff', '33'), ('8b4513', '53 UFD'), ('8b4513', '3'), ('8b4513', '17'), ('8b4513', '4'), ('8b4513', '19'), ('8b4513', '18'), ('bbbb00', '25'), ('bbbb00', '34'), ('bbbb00', '31'), ('bbbb00', '27'), ('0000ff', '33'), ('0000ff', '33'), ('8b4513', '53 UFD'), ('8b4513', '3'), ('8b4513', '17'), ('8b4513', '4'), ('8b4513', '19'), ('8b4513', '18'), ('ff0000', '25'), ('ff0000', '53 DSQ'), ('0000ff', '29'), ('0000ff', '42'), ('0000ff', '32'), ('0000ff', '24'), ('8b4513', '10'), ('8b4513', '14'), ('8b4513', '11'), ('8b4513', '17'), ('8b4513', '9'), ('8b4513', '53'), ('ff0000', '25'), ('ff0000', '53 DSQ'), ('0000ff', '29'), ('0000ff', '42'), ('0000ff', '32'), ('0000ff', '24'), ('8b4513', '10'), ('8b4513', '14'), ('8b4513', '11'), ('8b4513', '17'), ('8b4513', '9'), ('8b4513', '53'), ('0000ff', '13'), ('0000ff', '37'), ('ff0000', '29'), ('ff0000', '41'), ('bbbb00', '43'), ('bbbb00', '34'), ('8b4513', '1'), ('8b4513', '33'), ('8b4513', '7'), ('8b4513', '21'), ('8b4513', '28'), ('8b4513', '11'), ('0000ff', '13'), ('0000ff', '37'), ('ff0000', '29'), ('ff0000', '41'), ('bbbb00', '43'), ('bbbb00', '34'), ('8b4513', '1'), ('8b4513', '33'), ('8b4513', '7'), ('8b4513', '21'), ('8b4513', '28'), ('8b4513', '11'), ('bbbb00', '22'), ('bbbb00', '39'), ('ff0000', '41'), ('ff0000', '43'), ('0000ff', '23'), ('0000ff', '38'), ('8b4513', '11'), ('8b4513', '11'), ('8b4513', '21'), ('8b4513', '36'), ('8b4513', '3'), ('8b4513', '12'), ('bbbb00', '22'), ('bbbb00', '39'), ('ff0000', '41'), ('ff0000', '43'), ('0000ff', '23'), ('0000ff', '38'), ('8b4513', '11'), ('8b4513', '11'), ('8b4513', '21'), ('8b4513', '36'), ('8b4513', '3'), ('8b4513', '12'), ('ff0000', '38'), ('ff0000', '53 BFD'), ('ff0000', '37'), ('ff0000', '25'), ('bbbb00', '34'), ('bbbb00', '19'), ('8b4513', '24'), ('8b4513', '22'), ('8b4513', '14'), ('8b4513', '31'), ('8b4513', '14'), ('8b4513', '6'), ('ff0000', '38'), ('ff0000', '53 BFD'), ('ff0000', '37'), ('ff0000', '25'), ('bbbb00', '34'), ('bbbb00', '19'), ('8b4513', '24'), ('8b4513', '22'), ('8b4513', '14'), ('8b4513', '31'), ('8b4513', '14'), ('8b4513', '6'), ('bbbb00', '32'), ('bbbb00', '53 BFD'), ('ff0000', '39'), ('ff0000', '20'), ('bbbb00', '45'), ('bbbb00', '45'), ('8b4513', '15'), ('8b4513', '1'), ('8b4513', '10'), ('8b4513', '16'), ('8b4513', '35'), ('8b4513', '15'), ('bbbb00', '32'), ('bbbb00', '53 BFD'), ('ff0000', '39'), ('ff0000', '20'), ('bbbb00', '45'), ('bbbb00', '45'), ('8b4513', '15'), ('8b4513', '1'), ('8b4513', '10'), ('8b4513', '16'), ('8b4513', '35'), ('8b4513', '15'), ('bbbb00', '44'), ('bbbb00', '22'), ('0000ff', '37'), ('0000ff', '45'), ('ff0000', '41'), ('ff0000', '41'), ('8b4513', '6'), ('8b4513', '20'), ('8b4513', '53 RET'), ('8b4513', '2'), ('8b4513', '5'), ('8b4513', '14'), ('bbbb00', '44'), ('bbbb00', '22'), ('0000ff', '37'), ('0000ff', '45'), ('ff0000', '41'), ('ff0000', '41'), ('8b4513', '6'), ('8b4513', '20'), ('8b4513', '53 RET'), ('8b4513', '2'), ('8b4513', '5'), ('8b4513', '14'), ('0000ff', '45'), ('0000ff', '40'), ('0000ff', '30'), ('0000ff', '37'), ('0000ff', '16'), ('0000ff', '26'), ('8b4513', '28'), ('8b4513', '25'), ('8b4513', '13'), ('8b4513', '20'), ('8b4513', '22'), ('8b4513', '22'), ('0000ff', '45'), ('0000ff', '40'), ('0000ff', '30'), ('0000ff', '37'), ('0000ff', '16'), ('0000ff', '26'), ('8b4513', '28'), ('8b4513', '25'), ('8b4513', '13'), ('8b4513', '20'), ('8b4513', '22'), ('8b4513', '22'), ('0000ff', '50'), ('0000ff', '36'), ('bbbb00', '38'), ('bbbb00', '41'), ('bbbb00', '41'), ('bbbb00', '44'), ('8b4513', '27'), ('8b4513', '9'), ('8b4513', '28'), ('8b4513', '10'), ('8b4513', '7'), ('8b4513', '3'), ('0000ff', '50'), ('0000ff', '36'), ('bbbb00', '38'), ('bbbb00', '41'), ('bbbb00', '41'), ('bbbb00', '44'), ('8b4513', '27'), ('8b4513', '9'), ('8b4513', '28'), ('8b4513', '10'), ('8b4513', '7'), ('8b4513', '3'), ('ff0000', '42'), ('ff0000', '53 BFD'), ('0000ff', '39'), ('0000ff', '47'), ('0000ff', '39'), ('0000ff', '41'), ('8b4513', '5'), ('8b4513', '18'), ('8b4513', '8'), ('8b4513', '22'), ('8b4513', '13'), ('8b4513', '13'), ('ff0000', '42'), ('ff0000', '53 BFD'), ('0000ff', '39'), ('0000ff', '47'), ('0000ff', '39'), ('0000ff', '41'), ('8b4513', '5'), ('8b4513', '18'), ('8b4513', '8'), ('8b4513', '22'), ('8b4513', '13'), ('8b4513', '13'), ('0000ff', '31'), ('0000ff', '39'), ('0000ff', '28'), ('0000ff', '43'), ('0000ff', '37'), ('0000ff', '36'), ('8b4513', '32'), ('8b4513', '7'), ('8b4513', '23'), ('8b4513', '18'), ('8b4513', '24'), ('8b4513', '5'), ('0000ff', '31'), ('0000ff', '39'), ('0000ff', '28'), ('0000ff', '43'), ('0000ff', '37'), ('0000ff', '36'), ('8b4513', '32'), ('8b4513', '7'), ('8b4513', '23'), ('8b4513', '18'), ('8b4513', '24'), ('8b4513', '5'), ('bbbb00', '42'), ('bbbb00', '30'), ('ff0000', '34'), ('ff0000', '39'), ('bbbb00', '33'), ('bbbb00', '43'), ('8b4513', '4'), ('8b4513', '24'), ('8b4513', '27'), ('8b4513', '34'), ('8b4513', '8'), ('8b4513', '9'), ('bbbb00', '42'), ('bbbb00', '30'), ('ff0000', '34'), ('ff0000', '39'), ('bbbb00', '33'), ('bbbb00', '43'), ('8b4513', '4'), ('8b4513', '24'), ('8b4513', '27'), ('8b4513', '34'), ('8b4513', '8'), ('8b4513', '9'), ('ff0000', '28'), ('ff0000', '53 BFD'), ('ff0000', '35'), ('ff0000', '44'), ('bbbb00', '35'), ('bbbb00', '38'), ('8b4513', '26'), ('8b4513', '38'), ('8b4513', '16'), ('8b4513', '19'), ('8b4513', '10'), ('8b4513', '4'), ('ff0000', '28'), ('ff0000', '53 BFD'), ('ff0000', '35'), ('ff0000', '44'), ('bbbb00', '35'), ('bbbb00', '38'), ('8b4513', '26'), ('8b4513', '38'), ('8b4513', '16'), ('8b4513', '19'), ('8b4513', '10'), ('8b4513', '4'), ('bbbb00', '46'), ('bbbb00', '17'), ('bbbb00', '37'), ('bbbb00', '35'), ('0000ff', '42'), ('0000ff', '34'), ('8b4513', '13'), ('8b4513', '23'), ('8b4513', '53 DSQ'), ('8b4513', '15'), ('8b4513', '26'), ('8b4513', '10'), ('bbbb00', '46'), ('bbbb00', '17'), ('bbbb00', '37'), ('bbbb00', '35'), ('0000ff', '42'), ('0000ff', '34'), ('8b4513', '13'), ('8b4513', '23'), ('8b4513', '53 DSQ'), ('8b4513', '15'), ('8b4513', '26'), ('8b4513', '10'), ('ff0000', '4'), ('ff0000', '30'), ('0000ff', '40'), ('0000ff', '39'), ('0000ff', '45'), ('0000ff', '46'), ('8b4513', '12'), ('8b4513', '43'), ('8b4513', '15'), ('8b4513', '12'), ('8b4513', '32'), ('8b4513', '26'), ('ff0000', '4'), ('ff0000', '30'), ('0000ff', '40'), ('0000ff', '39'), ('0000ff', '45'), ('0000ff', '46'), ('8b4513', '12'), ('8b4513', '43'), ('8b4513', '15'), ('8b4513', '12'), ('8b4513', '32'), ('8b4513', '26'), ('0000ff', '39'), ('0000ff', '42'), ('0000ff', '33'), ('0000ff', '38'), ('ff0000', '42'), ('ff0000', '37'), ('8b4513', '23'), ('8b4513', '37'), ('8b4513', '22'), ('8b4513', '1'), ('8b4513', '4'), ('8b4513', '23'), ('0000ff', '39'), ('0000ff', '42'), ('0000ff', '33'), ('0000ff', '38'), ('ff0000', '42'), ('ff0000', '37'), ('8b4513', '23'), ('8b4513', '37'), ('8b4513', '22'), ('8b4513', '1'), ('8b4513', '4'), ('8b4513', '23'), ('bbbb00', '33'), ('bbbb00', '33'), ('bbbb00', '39'), ('bbbb00', '36'), ('ff0000', '44'), ('ff0000', '33'), ('8b4513', '19'), ('8b4513', '8'), ('8b4513', '33'), ('8b4513', '27'), ('8b4513', '18'), ('8b4513', '17'), ('bbbb00', '33'), ('bbbb00', '33'), ('bbbb00', '39'), ('bbbb00', '36'), ('ff0000', '44'), ('ff0000', '33'), ('8b4513', '19'), ('8b4513', '8'), ('8b4513', '33'), ('8b4513', '27'), ('8b4513', '18'), ('8b4513', '17'), ('ff0000', '37'), ('ff0000', '53 BFD'), ('0000ff', '32'), ('0000ff', '46'), ('bbbb00', '40'), ('bbbb00', '42'), ('8b4513', '16'), ('8b4513', '19'), ('8b4513', '9'), ('8b4513', '7'), ('8b4513', '33'), ('8b4513', '25'), ('ff0000', '37'), ('ff0000', '53 BFD'), ('0000ff', '32'), ('0000ff', '46'), ('bbbb00', '40'), ('bbbb00', '42'), ('8b4513', '16'), ('8b4513', '19'), ('8b4513', '9'), ('8b4513', '7'), ('8b4513', '33'), ('8b4513', '25'), ('bbbb00', '10'), ('bbbb00', '53 BFD'), ('0000ff', '42'), ('0000ff', '51.6 DPI'), ('bbbb00', '48'), ('bbbb00', '46'), ('8b4513', '18'), ('8b4513', '30'), ('8b4513', '19'), ('8b4513', '5'), ('8b4513', '29'), ('8b4513', '19'), ('bbbb00', '10'), ('bbbb00', '53 BFD'), ('0000ff', '42'), ('0000ff', '51.6 DPI'), ('bbbb00', '48'), ('bbbb00', '46'), ('8b4513', '18'), ('8b4513', '30'), ('8b4513', '19'), ('8b4513', '5'), ('8b4513', '29'), ('8b4513', '19'), ('0000ff', '35'), ('0000ff', '53 BFD'), ('ff0000', '45'), ('ff0000', '38'), ('ff0000', '38'), ('ff0000', '39'), ('8b4513', '20'), ('8b4513', '5'), ('8b4513', '20'), ('8b4513', '11'), ('8b4513', '15'), ('8b4513', '53'), ('0000ff', '35'), ('0000ff', '53 BFD'), ('ff0000', '45'), ('ff0000', '38'), ('ff0000', '38'), ('ff0000', '39'), ('8b4513', '20'), ('8b4513', '5'), ('8b4513', '20'), ('8b4513', '11'), ('8b4513', '15'), ('8b4513', '53'), ('bbbb00', '43'), ('bbbb00', '36'), ('0000ff', '21'), ('0000ff', '40'), ('ff0000', '22'), ('ff0000', '36'), ('8b4513', '25'), ('8b4513', '10'), ('8b4513', '31'), ('8b4513', '38'), ('8b4513', '27'), ('8b4513', '24'), ('bbbb00', '43'), ('bbbb00', '36'), ('0000ff', '21'), ('0000ff', '40'), ('ff0000', '22'), ('ff0000', '36'), ('8b4513', '25'), ('8b4513', '10'), ('8b4513', '31'), ('8b4513', '38'), ('8b4513', '27'), ('8b4513', '24'), ('ff0000', '44'), ('ff0000', '53 BFD'), ('bbbb00', '44'), ('bbbb00', '44'), ('bbbb00', '47'), ('bbbb00', '40'), ('8b4513', '14'), ('8b4513', '13'), ('8b4513', '6'), ('8b4513', '8'), ('8b4513', '30'), ('8b4513', '29'), ('ff0000', '44'), ('ff0000', '53 BFD'), ('bbbb00', '44'), ('bbbb00', '44'), ('bbbb00', '47'), ('bbbb00', '40'), ('8b4513', '14'), ('8b4513', '13'), ('8b4513', '6'), ('8b4513', '8'), ('8b4513', '30'), ('8b4513', '29'), ('ff0000', '43'), ('ff0000', '31'), ('bbbb00', '45'), ('bbbb00', '43'), ('0000ff', '48'), ('0000ff', '45'), ('8b4513', '2'), ('8b4513', '12'), ('8b4513', '34'), ('8b4513', '13'), ('8b4513', '20'), ('8b4513', '30'), ('ff0000', '43'), ('ff0000', '31'), ('bbbb00', '45'), ('bbbb00', '43'), ('0000ff', '48'), ('0000ff', '45'), ('8b4513', '2'), ('8b4513', '12'), ('8b4513', '34'), ('8b4513', '13'), ('8b4513', '20'), ('8b4513', '30'), ('bbbb00', '15'), ('bbbb00', '26'), ('ff0000', '53 DNF'), ('ff0000', '45'), ('0000ff', '43'), ('0000ff', '39'), ('8b4513', '22'), ('8b4513', '45'), ('8b4513', '32'), ('8b4513', '28'), ('8b4513', '11'), ('8b4513', '20'), ('bbbb00', '15'), ('bbbb00', '26'), ('ff0000', '53 DNF'), ('ff0000', '45'), ('0000ff', '43'), ('0000ff', '39'), ('8b4513', '22'), ('8b4513', '45'), ('8b4513', '32'), ('8b4513', '28'), ('8b4513', '11'), ('8b4513', '20'), ('0000ff', '10'), ('0000ff', '41'), ('0000ff', '38'), ('0000ff', '44'), ('bbbb00', '39'), ('bbbb00', '36'), ('8b4513', '53 RET'), ('8b4513', '32'), ('8b4513', '18'), ('8b4513', '24'), ('8b4513', '21'), ('8b4513', '28'), ('0000ff', '10'), ('0000ff', '41'), ('0000ff', '38'), ('0000ff', '44'), ('bbbb00', '39'), ('bbbb00', '36'), ('8b4513', '53 RET'), ('8b4513', '32'), ('8b4513', '18'), ('8b4513', '24'), ('8b4513', '21'), ('8b4513', '28'), ('ff0000', '41'), ('ff0000', '37'), ('bbbb00', '42'), ('bbbb00', '40'), ('ff0000', '45'), ('ff0000', '43'), ('8b4513', '36'), ('8b4513', '31'), ('8b4513', '24'), ('8b4513', '23'), ('8b4513', '23'), ('8b4513', '27'), ('ff0000', '41'), ('ff0000', '37'), ('bbbb00', '42'), ('bbbb00', '40'), ('ff0000', '45'), ('ff0000', '43'), ('8b4513', '36'), ('8b4513', '31'), ('8b4513', '24'), ('8b4513', '23'), ('8b4513', '23'), ('8b4513', '27'), ('ff0000', '39'), ('ff0000', '53 BFD'), ('bbbb00', '40'), ('bbbb00', '45'), ('bbbb00', '46'), ('bbbb00', '47'), ('8b4513', '31'), ('8b4513', '2'), ('8b4513', '53 RET'), ('8b4513', '14'), ('8b4513', '31'), ('8b4513', '33'), ('ff0000', '39'), ('ff0000', '53 BFD'), ('bbbb00', '40'), ('bbbb00', '45'), ('bbbb00', '46'), ('bbbb00', '47'), ('8b4513', '31'), ('8b4513', '2'), ('8b4513', '53 RET'), ('8b4513', '14'), ('8b4513', '31'), ('8b4513', '33'), ('bbbb00', '39'), ('bbbb00', '38'), ('ff0000', '44'), ('ff0000', '46'), ('0000ff', '47'), ('0000ff', '49'), ('8b4513', '30'), ('8b4513', '15'), ('8b4513', '37'), ('8b4513', '32'), ('8b4513', '34'), ('8b4513', '21'), ('bbbb00', '39'), ('bbbb00', '38'), ('ff0000', '44'), ('ff0000', '46'), ('0000ff', '47'), ('0000ff', '49'), ('8b4513', '30'), ('8b4513', '15'), ('8b4513', '37'), ('8b4513', '32'), ('8b4513', '34'), ('8b4513', '21'), ('ff0000', '34'), ('ff0000', '35'), ('bbbb00', '47'), ('bbbb00', '42'), ('0000ff', '49'), ('0000ff', '47'), ('8b4513', '21'), ('8b4513', '27'), ('8b4513', '38'), ('8b4513', '40'), ('8b4513', '37'), ('8b4513', '34'), ('ff0000', '34'), ('ff0000', '35'), ('bbbb00', '47'), ('bbbb00', '42'), ('0000ff', '49'), ('0000ff', '47'), ('8b4513', '21'), ('8b4513', '27'), ('8b4513', '38'), ('8b4513', '40'), ('8b4513', '37'), ('8b4513', '34'), ('0000ff', '47'), ('0000ff', '44'), ('0000ff', '41'), ('0000ff', '48'), ('0000ff', '46'), ('0000ff', '50'), ('8b4513', '33'), ('8b4513', '17'), ('8b4513', '30'), ('8b4513', '42'), ('8b4513', '25'), ('8b4513', '32'), ('0000ff', '47'), ('0000ff', '44'), ('0000ff', '41'), ('0000ff', '48'), ('0000ff', '46'), ('0000ff', '50'), ('8b4513', '33'), ('8b4513', '17'), ('8b4513', '30'), ('8b4513', '42'), ('8b4513', '25'), ('8b4513', '32'), ('0000ff', '48'), ('0000ff', '45'), ('ff0000', '47'), ('ff0000', '47'), ('0000ff', '41'), ('0000ff', '43'), ('8b4513', '41'), ('8b4513', '35'), ('8b4513', '29'), ('8b4513', '30'), ('8b4513', '17'), ('8b4513', '31'), ('0000ff', '48'), ('0000ff', '45'), ('ff0000', '47'), ('ff0000', '47'), ('0000ff', '41'), ('0000ff', '43'), ('8b4513', '41'), ('8b4513', '35'), ('8b4513', '29'), ('8b4513', '30'), ('8b4513', '17'), ('8b4513', '31'), ('ff0000', '49'), ('ff0000', '33'), ('bbbb00', '49'), ('bbbb00', '48'), ('ff0000', '46'), ('ff0000', '44'), ('8b4513', '40'), ('8b4513', '29'), ('8b4513', '5'), ('8b4513', '43'), ('8b4513', '36'), ('8b4513', '36'), ('ff0000', '49'), ('ff0000', '33'), ('bbbb00', '49'), ('bbbb00', '48'), ('ff0000', '46'), ('ff0000', '44'), ('8b4513', '40'), ('8b4513', '29'), ('8b4513', '5'), ('8b4513', '43'), ('8b4513', '36'), ('8b4513', '36'), ('0000ff', '42'), ('0000ff', '47'), ('bbbb00', '46'), ('bbbb00', '47'), ('0000ff', '50'), ('0000ff', '50.6 DPI'), ('8b4513', '34'), ('8b4513', '16'), ('8b4513', '35'), ('8b4513', '29'), ('8b4513', '38'), ('8b4513', '35'), ('0000ff', '42'), ('0000ff', '47'), ('bbbb00', '46'), ('bbbb00', '47'), ('0000ff', '50'), ('0000ff', '50.6 DPI'), ('8b4513', '34'), ('8b4513', '16'), ('8b4513', '35'), ('8b4513', '29'), ('8b4513', '38'), ('8b4513', '35'), ('bbbb00', '47'), ('bbbb00', '40'), ('0000ff', '36'), ('0000ff', '33'), ('ff0000', '43'), ('ff0000', '35'), ('8b4513', '37'), ('8b4513', '50'), ('8b4513', '36'), ('8b4513', '35'), ('8b4513', '39'), ('8b4513', '37'), ('bbbb00', '47'), ('bbbb00', '40'), ('0000ff', '36'), ('0000ff', '33'), ('ff0000', '43'), ('ff0000', '35'), ('8b4513', '37'), ('8b4513', '50'), ('8b4513', '36'), ('8b4513', '35'), ('8b4513', '39'), ('8b4513', '37'), ('bbbb00', '51'), ('bbbb00', '43'), ('ff0000', '48'), ('ff0000', '48'), ('ff0000', '47'), ('ff0000', '45'), ('8b4513', '35'), ('8b4513', '36'), ('8b4513', '25'), ('8b4513', '33'), ('8b4513', '41'), ('8b4513', '39'), ('bbbb00', '51'), ('bbbb00', '43'), ('ff0000', '48'), ('ff0000', '48'), ('ff0000', '47'), ('ff0000', '45'), ('8b4513', '35'), ('8b4513', '36'), ('8b4513', '25'), ('8b4513', '33'), ('8b4513', '41'), ('8b4513', '39'), ('ff0000', '45'), ('ff0000', '34'), ('bbbb00', '43'), ('bbbb00', '48.6 DPI'), ('bbbb00', '44'), ('bbbb00', '48'), ('8b4513', '39'), ('8b4513', '39'), ('8b4513', '41'), ('8b4513', '37'), ('8b4513', '40'), ('8b4513', '38'), ('ff0000', '45'), ('ff0000', '34'), ('bbbb00', '43'), ('bbbb00', '48.6 DPI'), ('bbbb00', '44'), ('bbbb00', '48'), ('8b4513', '39'), ('8b4513', '39'), ('8b4513', '41'), ('8b4513', '37'), ('8b4513', '40'), ('8b4513', '38'), ('0000ff', '49'), ('0000ff', '48'), ('0000ff', '53 BFD'), ('0000ff', '50'), ('ff0000', '48'), ('ff0000', '46'), ('8b4513', '29'), ('8b4513', '41'), ('8b4513', '39'), ('8b4513', '39'), ('8b4513', '47'), ('8b4513', '41'), ('0000ff', '49'), ('0000ff', '48'), ('0000ff', '53 BFD'), ('0000ff', '50'), ('ff0000', '48'), ('ff0000', '46'), ('8b4513', '29'), ('8b4513', '41'), ('8b4513', '39'), ('8b4513', '39'), ('8b4513', '47'), ('8b4513', '41'), ('ff0000', '52'), ('ff0000', '36'), ('ff0000', '49'), ('ff0000', '49'), ('bbbb00', '50'), ('bbbb00', '51'), ('8b4513', '38'), ('8b4513', '26'), ('8b4513', '46'), ('8b4513', '47'), ('8b4513', '48'), ('8b4513', '43'), ('ff0000', '52'), ('ff0000', '36'), ('ff0000', '49'), ('ff0000', '49'), ('bbbb00', '50'), ('bbbb00', '51'), ('8b4513', '38'), ('8b4513', '26'), ('8b4513', '46'), ('8b4513', '47'), ('8b4513', '48'), ('8b4513', '43'), ('ff0000', '50'), ('ff0000', '32'), ('bbbb00', '50'), ('bbbb00', '51'), ('ff0000', '49'), ('ff0000', '47'), ('8b4513', '42'), ('8b4513', '34'), ('8b4513', '45'), ('8b4513', '44'), ('8b4513', '49'), ('8b4513', '42'), ('ff0000', '50'), ('ff0000', '32'), ('bbbb00', '50'), ('bbbb00', '51'), ('ff0000', '49'), ('ff0000', '47'), ('8b4513', '42'), ('8b4513', '34'), ('8b4513', '45'), ('8b4513', '44'), ('8b4513', '49'), ('8b4513', '42'), ('bbbb00', '50'), ('bbbb00', '42'), ('bbbb00', '52'), ('bbbb00', '52'), ('ff0000', '50'), ('ff0000', '49'), ('8b4513', '43'), ('8b4513', '42'), ('8b4513', '42'), ('8b4513', '41'), ('8b4513', '45'), ('8b4513', '48'), ('bbbb00', '50'), ('bbbb00', '42'), ('bbbb00', '52'), ('bbbb00', '52'), ('ff0000', '50'), ('ff0000', '49'), ('8b4513', '43'), ('8b4513', '42'), ('8b4513', '42'), ('8b4513', '41'), ('8b4513', '45'), ('8b4513', '48'), ('0000ff', '46'), ('0000ff', '46'), ('0000ff', '44'), ('0000ff', '52'), ('ff0000', '51'), ('ff0000', '48'), ('8b4513', '45'), ('8b4513', '40'), ('8b4513', '40'), ('8b4513', '49'), ('8b4513', '51'), ('8b4513', '45'), ('0000ff', '46'), ('0000ff', '46'), ('0000ff', '44'), ('0000ff', '52'), ('ff0000', '51'), ('ff0000', '48'), ('8b4513', '45'), ('8b4513', '40'), ('8b4513', '40'), ('8b4513', '49'), ('8b4513', '51'), ('8b4513', '45'), ('bbbb00', '52'), ('bbbb00', '44'), ('bbbb00', '48'), ('bbbb00', '49'), ('bbbb00', '49'), ('bbbb00', '49'), ('8b4513', '49'), ('8b4513', '47'), ('8b4513', '48'), ('8b4513', '45'), ('8b4513', '42'), ('8b4513', '40'), ('bbbb00', '52'), ('bbbb00', '44'), ('bbbb00', '48'), ('bbbb00', '49'), ('bbbb00', '49'), ('bbbb00', '49'), ('8b4513', '49'), ('8b4513', '47'), ('8b4513', '48'), ('8b4513', '45'), ('8b4513', '42'), ('8b4513', '40'), ('bbbb00', '49'), ('bbbb00', '41'), ('ff0000', '50'), ('ff0000', '51'), ('bbbb00', '51'), ('bbbb00', '50'), ('8b4513', '47'), ('8b4513', '46'), ('8b4513', '47'), ('8b4513', '48'), ('8b4513', '43'), ('8b4513', '44'), ('bbbb00', '49'), ('bbbb00', '41'), ('ff0000', '50'), ('ff0000', '51'), ('bbbb00', '51'), ('bbbb00', '50'), ('8b4513', '47'), ('8b4513', '46'), ('8b4513', '47'), ('8b4513', '48'), ('8b4513', '43'), ('8b4513', '44'), ('bbbb00', '40'), ('bbbb00', '16'), ('0000ff', '53 BFD'), ('0000ff', '41'), ('ff0000', '53 DNC'), ('ff0000', '53 DNC'), ('8b4513', '53 DNC'), ('8b4513', '53 DNC'), ('8b4513', '53 DNC'), ('8b4513', '53 DNC'), ('8b4513', '53 DNC'), ('8b4513', '53'), ('bbbb00', '40'), ('bbbb00', '16'), ('0000ff', '53 BFD'), ('0000ff', '41'), ('ff0000', '53 DNC'), ('ff0000', '53 DNC'), ('8b4513', '53 DNC'), ('8b4513', '53 DNC'), ('8b4513', '53 DNC'), ('8b4513', '53 DNC'), ('8b4513', '53 DNC'), ('8b4513', '53'), ('0000ff', '51'), ('0000ff', '50'), ('bbbb00', '51'), ('bbbb00', '50'), ('bbbb00', '52'), ('bbbb00', '52'), ('8b4513', '46'), ('8b4513', '44'), ('8b4513', '43'), ('8b4513', '46'), ('8b4513', '44'), ('8b4513', '53'), ('0000ff', '51'), ('0000ff', '50'), ('bbbb00', '51'), ('bbbb00', '50'), ('bbbb00', '52'), ('bbbb00', '52'), ('8b4513', '46'), ('8b4513', '44'), ('8b4513', '43'), ('8b4513', '46'), ('8b4513', '44'), ('8b4513', '53'), ('ff0000', '48'), ('ff0000', '53 BFD'), ('ff0000', '51'), ('ff0000', '50'), ('0000ff', '51'), ('0000ff', '52'), ('8b4513', '48'), ('8b4513', '48'), ('8b4513', '44'), ('8b4513', '50'), ('8b4513', '46'), ('8b4513', '47'), ('ff0000', '48'), ('ff0000', '53 BFD'), ('ff0000', '51'), ('ff0000', '50'), ('0000ff', '51'), ('0000ff', '52'), ('8b4513', '48'), ('8b4513', '48'), ('8b4513', '44'), ('8b4513', '50'), ('8b4513', '46'), ('8b4513', '47'), ('0000ff', '52'), ('0000ff', '49'), ('0000ff', '43'), ('0000ff', '51'), ('0000ff', '52'), ('0000ff', '51'), ('8b4513', '44'), ('8b4513', '51'), ('8b4513', '49'), ('8b4513', '51'), ('8b4513', '50'), ('8b4513', '46'), ('0000ff', '52'), ('0000ff', '49'), ('0000ff', '43'), ('0000ff', '51'), ('0000ff', '52'), ('0000ff', '51'), ('8b4513', '44'), ('8b4513', '51'), ('8b4513', '49'), ('8b4513', '51'), ('8b4513', '50'), ('8b4513', '46')]\n\ndef blah():\n tstname='worldChamps2019.csv'\n\n df = pd.read_csv(tstname)\n\n # for index, row in df.iterrows():\n # print (index, row[5])\n\n # df.columns = df.iloc[1]\n\n # print (df.columns, '\\n')\n\n # print(df.columns[0]==1,'\\n')\n\n # df.drop(columns=[1, 'Pos','Bow#'], inplace=True)\n # df.dropna(axis = 1,inplace=True)\n # df.drop_duplicates(inplace=True)\n\n # for index, row in df.iterrows():\n # df['Name'][index] = ' '.join(reversed(row['Name'].split(' ')))\n\n QR1_blue = []\n QR1_red = []\n QR1_yellow = []\n\n QR2_blue = []\n QR2_red = []\n QR2_yellow = []\n\n QR3_blue = []\n QR3_red = []\n QR3_yellow = []\n\n QR4_blue = []\n QR4_red = []\n QR4_yellow = []\n\n QR5_blue = []\n QR5_red = []\n QR5_yellow = []\n\n QR6_blue = []\n QR6_red = []\n QR6_yellow = []\n\n FR7_gold = []\n FR7_silver = []\n FR7_bronze = []\n\n FR8_gold = []\n FR8_silver = []\n FR8_bronze = []\n\n FR9_gold = []\n FR9_silver = []\n FR9_bronze = []\n\n FR10_gold = []\n FR10_silver = []\n FR10_bronze = []\n\n FR11_gold = []\n FR11_silver = []\n FR11_bronze = []\n\n FR12_gold = []\n FR12_silver = []\n FR12_bronze = []\n\n\n lstQRs=[ QR1_blue , \\\n QR1_red , \\\n QR1_yellow , \\\n\n QR2_blue , \\\n QR2_red , \\\n QR2_yellow , \\\n\n QR3_blue , \\\n QR3_red , \\\n QR3_yellow , \\\n\n QR4_blue , \\\n QR4_red , \\\n QR4_yellow , \\\n\n QR5_blue , \\\n QR5_red , \\\n QR5_yellow , \\\n\n QR6_blue , \\\n QR6_red , \\\n QR6_yellow]\n\n lstFRs=[ FR7_gold , \\\n FR7_silver , \\\n FR7_bronze , \\\n\n FR8_gold , \\\n FR8_silver , \\\n FR8_bronze , \\\n\n FR9_gold , \\\n FR9_silver , \\\n FR9_bronze , \\\n\n FR10_gold , \\\n FR10_silver , \\\n FR10_bronze , \\\n\n FR11_gold , \\\n FR11_silver , \\\n FR11_bronze , \\\n\n FR12_gold , \\\n FR12_silver , \\\n FR12_bronze ]\n\n\n\n colors = {'0000ff': 'blue', 'bbbb00': 'yellow', '999900': 'gold', \n 'ff0000': 'red', '999999':'silver', '8b4513': 'bronze'}\n\n for index, row in df.iterrows():\n lstIndex = index*24\n # if int(colorlst[lstIndex][1]) == int(row['QR1']):\n # print(('{:39} scored '+str(row['QR1']) + '\\t in QR1'\\\n # ' with color code ' + colors.get(colorlst[lstIndex][0])).format(row['Name']) )\n colorKey = colorlst[lstIndex][0]\n if colors.get(colorKey) == 'blue':\n QR1_blue.append([row['Name'],row['QR1']])\n QR2_blue.append([row['Name'],row['QR2']])\n elif colors.get(colorKey) == 'red':\n QR1_red.append([row['Name'],row['QR1']])\n QR2_red.append([row['Name'],row['QR2']])\n elif colors.get(colorKey) == 'yellow':\n QR1_yellow.append([row['Name'],row['QR1']])\n QR2_yellow.append([row['Name'],row['QR2']])\n \n lstIndex += 2\n colorKey = colorlst[lstIndex][0]\n if colors.get(colorKey) == 'blue':\n QR3_blue.append([row['Name'],row['QR3']])\n QR4_blue.append([row['Name'],row['QR4']])\n elif colors.get(colorKey) == 'red':\n QR3_red.append([row['Name'],row['QR3']])\n QR4_red.append([row['Name'],row['QR4']])\n elif colors.get(colorKey) == 'yellow':\n QR3_yellow.append([row['Name'],row['QR3']])\n QR4_yellow.append([row['Name'],row['QR4']])\n\n lstIndex += 2\n colorKey = colorlst[lstIndex][0]\n if colors.get(colorKey) == 'blue':\n QR5_blue.append([row['Name'],row['QR5']])\n QR6_blue.append([row['Name'],row['QR6']])\n elif colors.get(colorKey) == 'red':\n QR5_red.append([row['Name'],row['QR5']])\n QR6_red.append([row['Name'],row['QR6']])\n elif colors.get(colorKey) == 'yellow':\n QR5_yellow.append([row['Name'],row['QR5']])\n QR6_yellow.append([row['Name'],row['QR6']])\n\n lstIndex += 2\n colorKey = colorlst[lstIndex][0]\n if colors.get(colorKey) == 'gold':\n FR7_gold.append([row['Name'],row['FR7']])\n FR8_gold.append([row['Name'],row['FR8']])\n FR9_gold.append([row['Name'],row['FR9']])\n FR10_gold.append([row['Name'],row['FR10']])\n FR11_gold.append([row['Name'],row['FR11']])\n FR12_gold.append([row['Name'],row['FR12']])\n elif colors.get(colorKey) == 'silver':\n FR7_silver.append([row['Name'],row['FR7']])\n FR8_silver.append([row['Name'],row['FR8']])\n FR9_silver.append([row['Name'],row['FR9']])\n FR10_silver.append([row['Name'],row['FR10']])\n FR11_silver.append([row['Name'],row['FR11']])\n FR12_silver.append([row['Name'],row['FR12']])\n elif colors.get(colorKey) == 'bronze':\n FR7_bronze.append([row['Name'],row['FR7']])\n FR8_bronze.append([row['Name'],row['FR8']])\n FR9_bronze.append([row['Name'],row['FR9']])\n FR10_bronze.append([row['Name'],row['FR10']])\n FR11_bronze.append([row['Name'],row['FR11']])\n FR12_bronze.append([row['Name'],row['FR12']])\n\n indexColors = {0:'blue', 1:'red', 2:'yellow'}\n for i in range(18):\n \n qr = lstQRs[i]\n qr.sort(key = lambda sailor:sailor[1])\n currentColor = indexColors.get(i % 3)\n QRnum = int(i / 3) + 1\n\n print(qr)\n\n for j in range(len(qr)):\n result = qr[j]\n sailor = result[0]\n rr = result[1]\n sailorIndex = df.loc[df['Name']==sailor].index\n\n colName = 'QR{}_{}'.format(str(QRnum),str(currentColor))\n print (\"{:39} had result {:3} in race {}\".format(\\\n sailor,rr,colName))\n try:\n df.at[sailorIndex,colName] = rr\n except Exception as e:\n df[colName] = np.nan\n df.at[sailorIndex,colName] = rr\n\n indexColors = {0:'gold', 1:'silver', 2:'bronze'}\n for i in range(18):\n \n fr = lstFRs[i]\n fr.sort(key = lambda sailor:sailor[1])\n currentColor = indexColors.get(i % 3)\n FRnum = int(i / 3) + 1\n\n print(fr)\n\n for j in range(len(fr)):\n result = fr[j]\n sailor = result[0]\n rr = result[1]\n sailorIndex = df.loc[df['Name']==sailor].index\n\n colName = 'FR{}_{}'.format(str(FRnum + 6),str(currentColor))\n print (\"{:39} had result {:3} in race {}\".format(\\\n sailor,rr,colName))\n try:\n df.at[sailorIndex,colName] = rr\n except Exception as e:\n df[colName] = np.nan\n df.at[sailorIndex,colName] = rr\n\n\n\n\n\n df.to_csv('MOD' + tstname, index=False)\n\n#rawHTML=\"\"\"\"\"\"\n\ndef blah2():\n Regex=re.compile(r'color=\" #([0-9a-f]{6})\">(?:<s>)?(\\d{1,2}|\\d{1,2}\\.?\\d?\\s[A-Z]{3})\\s?(?:<\\/s>)?<\\/font><\\/td>')\n print(Regex.findall(rawHTML))\n\n\n\n\ndef wc2020():\n df = pd.read_csv('WorldChamps2020.csv')\n\n # colors = {0:'yellow',1:'blue',2:'red'}\n # for i in range(1,7):\n # for j in range(3):\n # inputFile = 'WorldChamps2020R{}{}'.format(str(i),str(j))\n # dfTmp = pd.read_csv(inputFile + '.csv')\n # colName = 'QR{}_{}'.format(str(i),colors.get(j))\n\n # for index, row in dfTmp.iterrows():\n # sailor = row['Name'].replace(u'\\xa0', u' ')\n # rr = row['Points']\n # dfIndex = df.loc[df['Name']==sailor].index\n # try:\n # df.at[dfIndex,colName] = rr\n # except Exception as e:\n # df[colName] = np.nan\n # df.at[dfIndex,colName] = rr\n\n # colors = {0:'gold',1:'silver',2:'bronze'}\n # for i in range(7,13):\n # for j in range(3):\n # inputFile = 'WorldChamps2020R{}{}'.format(str(i),colors.get(j))\n # dfTmp = pd.read_csv(inputFile + '.csv')\n # colName = 'FR{}_{}'.format(str(i),colors.get(j))\n\n # for index, row in dfTmp.iterrows():\n # sailor = row['Name'].replace(u'\\xa0', u' ')\n # rr = row['Points']\n # dfIndex = df.loc[df['Name']==sailor].index\n # try:\n # df.at[dfIndex,colName] = rr\n # except Exception as e:\n # df[colName] = np.nan\n # df.at[dfIndex,colName] = rr\n\n # df.to_csv('WorldChamps2020Entries.csv',index=False)\n\n #df['Total'] = df.iloc[:,5:].sum(axis=1)\n #print(df['Total'])\n\n # df['Net'] = df['Total'] - df.iloc[:,5:18+4+1].max(axis=1) \\\n # - df.iloc[:,18+4+1:].max(axis=1)\n\n # print(df.at[3,'FR12_bronze'])\n # for index, row in df.iterrows():\n # #print(row['FR12_gold'])\n # if str(row['FR12_gold']) != 'nan':\n # df.at[index,'fleet'] = 1\n # elif str(row['FR12_silver']) != 'nan':\n # df.at[index,'fleet'] = 2\n # else:\n # df.at[index,'fleet'] = 3\n\n #df.sort_values(['fleet','Net'],inplace=True)\n\n #print( tabulate(df, headers='keys', tablefmt='psql'))\n\n df.to_csv('WorldChamps2020.csv',index=False)\n \ndef hempelWCmiami2019():\n df = pd.read_csv('HempelWCMiami2019Overall.csv')\n races = ['QR1_yellow','QR2_yellow','QR3_blue','QR4_blue','FR5_gold','FR6_gold','FR7_gold','FR8_gold','FR9_gold','FR10_gold','FR11_gold','FR_medal','QR3_yellow','QR4_yellow','QR1_blue','QR2_blue','FR5_silver','FR6_silver','FR7_silver','FR8_silver','FR9_silver','FR10_silver']\n\n for race in races:\n inputFile = 'HempelWCMiami2019{}.csv'.format(race)\n dfTmp = pd.read_csv(inputFile)\n\n for index, row in dfTmp.iterrows():\n sailor = row['Crew']\n rr = row['Race Points']\n dfIndex = df.loc[df['Name']==sailor].index\n try:\n df.at[dfIndex,race] = rr\n except Exception as e:\n df[race] = np.nan\n df.at[dfIndex,race] = rr\n\n df.to_csv('HempelWCMiami2019.csv')\n \n\n\n##### main ########\nhempelWCmiami2019()" ]

[ [ "pandas.read_csv" ] ]

jz5jx/Test_Repo

[ "8796f45021943984ed02232fd34ff02e17123d71" ]

[ "src/clustar_project/graph.py" ]

[ "import numpy as np\nimport matplotlib.pyplot as plt\nfrom matplotlib.patches import Rectangle\n\n\ndef identify_peaks(image, smoothing=5, clip=0.75):\n n_rows = image.shape[0]\n n_cols = image.shape[1]\n mid = n_rows // 2\n\n y = np.array([image[mid, c] for c in range(n_cols)])\n x = np.arange(0, len(y), 1)\n\n y_avg = []\n for i in range(len(y)):\n if i + smoothing > y.shape[0]:\n smoothing -= - 1\n if smoothing != 0:\n y_avg.append(np.mean(y[i:i + smoothing]))\n\n y = np.array(y_avg)\n dydx = np.diff(y) / np.diff(x)\n\n lhs = np.array([y[i - 1] / y[i] for i in\n range(1, len(y) // 2) if y[i] != 0])\n lhs[lhs < clip] = 0\n lhs = np.nonzero(lhs)[0]\n lhs = [lhs[i - 1] for i in range(1, len(lhs))\n if ((lhs[i] - lhs[i - 1]) == 1)]\n\n rhs = np.array([y[i] / y[i - 1] for i in\n range(len(y) - 1, len(y) // 2, -1)\n if y[i - 1] != 0])\n rhs[rhs < clip] = 0\n rhs = np.nonzero(rhs)[0]\n rhs = [rhs[i - 1] for i in\n range(1, len(rhs)) if ((rhs[i] - rhs[i - 1]) == 1)]\n\n idx = []\n\n if len(lhs) > 1 and len(rhs) > 1:\n dydx_ = dydx[lhs[0]:-rhs[0]]\n\n if len(dydx_) > 2:\n idx = np.array([i for i in range(1, len(dydx_))\n if (dydx_[i - 1] > 0 >= dydx_[i])\n or (dydx_[i - 1] < 0 <= dydx_[i])]) + lhs[0]\n\n idx = [idx[i] for i, val in enumerate(idx) if i % 2 == 0]\n\n return idx\n" ]

[ [ "numpy.array", "numpy.diff", "numpy.mean", "numpy.nonzero" ] ]

sjanzou/pvlib-python

[ "17751ca69f271891ee83082772b3261138e34dd0" ]

[ "pvlib/test/test_surfrad.py" ]

[ "import inspect\nimport os\n\nfrom pandas import Timestamp, DatetimeIndex\nfrom pandas.util.testing import network\n\nfrom pvlib.iotools import surfrad\n\ntest_dir = os.path.dirname(\n os.path.abspath(inspect.getfile(inspect.currentframe())))\ntestfile = os.path.join(test_dir, '../data/surfrad-slv16001.dat')\nnetwork_testfile = ('ftp://aftp.cmdl.noaa.gov/data/radiation/surfrad/'\n 'Alamosa_CO/2016/slv16001.dat')\n\n\n@network\ndef test_read_surfrad_network():\n # If this test begins failing, SURFRAD's data structure or data\n # archive may have changed.\n local_data, _ = surfrad.read_surfrad(testfile)\n network_data, _ = surfrad.read_surfrad(network_testfile)\n assert local_data.equals(network_data)\n\n\ndef test_read_surfrad_columns_no_map():\n data, _ = surfrad.read_surfrad(testfile, map_variables=False)\n assert 'zen' in data.columns\n assert 'temp' in data.columns\n assert 'par' in data.columns\n assert 'pressure' in data.columns\n\n\ndef test_read_surfrad_columns_map():\n data, _ = surfrad.read_surfrad(testfile)\n assert 'solar_zenith' in data.columns\n assert 'ghi' in data.columns\n assert 'ghi_flag' in data.columns\n assert 'dni' in data.columns\n assert 'dni_flag' in data.columns\n assert 'dhi' in data.columns\n assert 'dhi_flag' in data.columns\n assert 'wind_direction' in data.columns\n assert 'wind_direction_flag' in data.columns\n assert 'wind_speed' in data.columns\n assert 'wind_speed_flag' in data.columns\n assert 'temp_air' in data.columns\n assert 'temp_air_flag' in data.columns\n\n\ndef test_format_index():\n start = Timestamp('20160101 00:00')\n expected = DatetimeIndex(start=start, periods=1440, freq='1min', tz='UTC')\n actual, _ = surfrad.read_surfrad(testfile)\n assert actual.index.equals(expected)\n\n\ndef test_read_surfrad_metadata():\n expected = {'name': 'Alamosa',\n 'latitude': 37.70,\n 'longitude': 105.92,\n 'elevation': 2317,\n 'surfrad_version': 1,\n 'tz': 'UTC'}\n _, metadata = surfrad.read_surfrad(testfile)\n assert metadata == expected\n" ]

[ [ "pandas.Timestamp", "pandas.DatetimeIndex" ] ]