def wrap_obs(self, obs: np.array, dummy_value: float = 0.0) -> np.array: vardiff = self.to_vars - self.from_vars obs = list(obs) # insert observation value [ obs.insert(i, dummy_value) for i in range(self.from_vars, self.to_vars) ] # insert intervention value [ obs.insert(i, dummy_value) for i in range(self.to_vars + self.from_vars, 2 * self.to_vars) ] # insert graph state values acc_index = self.to_vars * 2 for i in range(self.from_vars - 1, 1, -1): acc_index += i [obs.insert(acc_index, dummy_value) for i in range(vardiff)] acc_index += vardiff # fill up until end while acc_index < (int((self.to_vars * 2) + self.to_vars * (self.to_vars - 1) / 2)) - 1: obs.append(dummy_value) acc_index += 1 return np.array(obs)
def run_saliency_map(model: keras.Model, data: np.array) -> np.array: """[summary] Args: model (keras.Model): [description] data (np.array): [description] Returns: np.array: [description] """ saliency = get_saliency(data, model) ts = str(calendar.timegm(time.gmtime())) saliency = np.median(saliency, axis=-1) filename_path = "./saliency.png" save_images_plot(saliency, filename_path) # samples_idx = sorted(range(len(saliency)), key=lambda i: saliency[i])[-20:] saliency_list = saliency.tolist() samples_idx = range(len(saliency_list)) data = [] for idx in samples_idx: data.append([idx, saliency_list[idx]]) return data
def real_data_loading(data: np.array, seq_len): """Load and preprocess real-world datasets. Args: - data_name: Numpy array with the values from a a Dataset - seq_len: sequence length Returns: - data: preprocessed data. """ # Flip the data to make chronological data ori_data = data[::-1] # Normalize the data scaler = MinMaxScaler().fit(ori_data) ori_data = scaler.transform(ori_data) # Preprocess the dataset temp_data = [] # Cut data by sequence length for i in range(0, len(ori_data) - seq_len): _x = ori_data[i:i + seq_len] temp_data.append(_x) # Mix the datasets (to make it similar to i.i.d) idx = np.random.permutation(len(temp_data)) data = [] for i in range(len(temp_data)): data.append(temp_data[idx[i]]) return data
def Rest(A: np.array, k: int, centers: np.array) -> np.array: """ Determines rest of centers to be used in Gonzalez. """ while k > 0: A[centers, :] = np.zeros((np.size(centers), np.shape(A)[1])) relevant = A[:, centers] min_each_row = np.amin(relevant, axis=1) maxmin = np.argmax(min_each_row) centers.append(maxmin) k -= 1 return np.array(centers)
def _generate_joints( events: np.array, joints: np.array, subject: str, action: str, output_joint_path: str, ) -> np.array: gt_generator = joint_generator(events, joints, num_events) joints = [] for joint_frame in gt_generator: joints.append(joint_frame) return np.stack(joints)
def generate(self, starting_sequence: np.array) -> np.array: for _ in range(self.sequence_length): predicted_character = np.argmax( self.model.predict( np.reshape(starting_sequence, (1, len(starting_sequence), 1)) / float(len(self.characters)) ) ) starting_sequence.append(predicted_character) starting_sequence = starting_sequence[1 : len(starting_sequence)] return starting_sequence
def func(x: np.array, inc: float, mu_f: np.array, sigma_f: np.array, acq_f: np.array, x_f: np.array) -> float: """function that is internally used as it is passed to the minimize takes input and calculates the respective acquisition value and negates it as minimize is used but the original problem is maximization :param x: input value :param inc: incumbent :param mu_f: list of mu values to append mu-prediction to for persistence :param sigma_f: list of sigma values to append sigma-prediction to for persistence :param acq_f: list of acquisition function values to append for to persistence :param x_f: list of acquisition function sample inputs to append to for persistence :return: """ within_bounds = True for i, x_d in enumerate(x): if x_d < self.lower_search_bounds[i] or x_d > self.upper_search_bounds[i]: within_bounds = False if not within_bounds: return 0 m, s = self.context.estimator.regress([x]) mu_f.append(m) sigma_f.append(s) a = self.context.acq.evaluate(m, s, inc) acq_f.append(a) x_f.append(x) return -a
def func(x: np.array, inc: float, mu_f: np.array, sigma_f: np.array, acq_f: np.array, x_f: np.array) -> float: """function that is internally used as it is passed to the minimize takes input and calculates the respective acquisition value and negates it as minimize is used but the original problem is maximization :param x: input value :param inc: incumbent :param mu_f: list of mu values to append mu-prediction to for persistence :param sigma_f: list of sigma values to append sigma-prediction to for persistence :param acq_f: list of acquisition function values to append for to persistence :param x_f: list of acquisition function sample inputs to append to for persistence :return: """ m, s = self.context.estimator.regress(np.array([x])) mu_f.append(m) sigma_f.append(s) a = self.context.acq.evaluate(m, s, inc) acq_f.append(a) x_f.append(x) if len(x_f) % 200 == 0: gc.collect() return -a
def _create_plane_mesh( self, vertices: np.array, vertices_floor: np.array, textures: typing.List[np.array], texture_floor: np.array, texture_ceiling: np.array, delta_height: np.array, ignore_ceiling: bool = False, ) -> open3d.geometry.TriangleMesh: # create mesh for 3D floorplan visualization triangles, triangle_uvs = [], [] num_walls = len(vertices) # the number of vertical walls # 1. vertical wall (always rectangle) num_vertices = 0 for i in range(len(vertices)): triangle = np.array( [[0, 2, 1], [2, 0, 3]]) # hardcode triangles for each vertical wall triangles.append(triangle + num_vertices) num_vertices += 4 triangle_uv = np.array( [[i / (num_walls + 2), 0], [i / (num_walls + 2), 1], [(i + 1) / (num_walls + 2), 1], [(i + 1) / (num_walls + 2), 0]], dtype=np.float32) triangle_uvs.append(triangle_uv) # 2. floor and ceiling tri = Triangulator( ) # Since the floor and ceiling may not be a rectangle, triangulate the polygon first. for i in range(len(vertices_floor)): tri.add_vertex(vertices_floor[i, 0], vertices_floor[i, 1]) for i in range(len(vertices_floor)): tri.add_polygon_vertex(i) tri.triangulate() # polygon triangulation triangle = [] for i in range(tri.getNumTriangles()): triangle.append([ tri.get_triangle_v0(i), tri.get_triangle_v1(i), tri.get_triangle_v2(i) ]) triangle = np.array(triangle) # add triangles for floor and ceiling triangles.append(triangle + num_vertices) num_vertices += len(np.unique(triangle)) if not ignore_ceiling: triangles.append(triangle + num_vertices) # texture for floor and ceiling vertices_floor_min = np.min(vertices_floor[:, :2], axis=0) vertices_floor_max = np.max(vertices_floor[:, :2], axis=0) # normalize to [0, 1] triangle_uv = (vertices_floor[:, :2] - vertices_floor_min) / ( vertices_floor_max - vertices_floor_min) triangle_uv[:, 0] = (triangle_uv[:, 0] + num_walls) / (num_walls + 2) triangle_uvs.append(triangle_uv) # normalize to [0, 1] triangle_uv = (vertices_floor[:, :2] - vertices_floor_min) / ( vertices_floor_max - vertices_floor_min) triangle_uv[:, 0] = (triangle_uv[:, 0] + num_walls + 1) / (num_walls + 2) triangle_uvs.append(triangle_uv) # 3. Merge wall, floor, and ceiling vertices.append(vertices_floor) vertices.append(vertices_floor + delta_height) vertices = np.concatenate(vertices, axis=0) triangles = np.concatenate(triangles, axis=0) textures.append(texture_floor) textures.append(texture_ceiling) textures = np.concatenate(textures, axis=1) triangle_uvs = np.concatenate(triangle_uvs, axis=0) mesh = open3d.geometry.TriangleMesh( vertices=open3d.utility.Vector3dVector(vertices), triangles=open3d.utility.Vector3iVector(triangles)) mesh.compute_vertex_normals() # mesh.compute_vertex_normals() mesh.texture = open3d.geometry.Image(textures) mesh.triangle_uvs = np.array(triangle_uvs[triangles.reshape(-1), :], dtype=np.float64) return mesh
def create_mesh( self, panorama: np.array, corners: np.array, floor_z: float = -1.6, ignore_ceiling: bool = True, ): H, W, C = panorama.shape top_corners, bottom_corners = corners[::2], corners[1::2] junctions_floor, junctions_ceiling = self._uv2xyz( bottom_corners, top_corners, floor_z, W, H) junctions_floor[:, -1] = 0.0 wall_height = np.mean(junctions_ceiling, axis=0)[-1] + abs(floor_z) delta_height = np.array([0, 0, wall_height]) corners, textures = [], [] # 3D coordinate & texture for each wall camera_center = np.array([0.0, 0.0, abs(floor_z)]) for corner_i, corner_j in zip( junctions_floor, np.roll(junctions_floor, shift=-1, axis=0)): corner_j, corner_i = corner_i, corner_j texture = self._equirectangular_to_perspective(panorama, corner_i, corner_j, wall_height, camera_center, input_resolution=W, output_resolution=W, is_wall=True) corner = np.array([ corner_i, corner_i + delta_height, corner_j + delta_height, corner_j ]) corners.append(corner) textures.append(texture) # the floor/ceiling texture is cropped by the maximum bounding box corner_min = np.min(junctions_floor, axis=0) corner_max = np.max(junctions_floor, axis=0) texture_floor = self._equirectangular_to_perspective( panorama, corner_min, corner_max, 0, camera_center, input_resolution=W, output_resolution=W, is_wall=False) texture_ceiling = self._equirectangular_to_perspective( panorama, corner_min, corner_max, wall_height, camera_center, input_resolution=W, output_resolution=W, is_wall=False) mesh = self._create_plane_mesh(corners, junctions_floor, textures, texture_floor, texture_ceiling, delta_height, ignore_ceiling=ignore_ceiling) return mesh