def cluster_emb(self, entities): kmeans_model, kmeans_model2, left_weights, right_weights =\ self.cluster(self, entities) left_cluster_labels = kmeans_model.labels_ right_cluster_labels = kmeans_model2.labels_ left_emb = kmeans_model.cluster_centers_ right_emb = kmeans_model2.cluster_centers_ left_weight_result = autovivify_list() right_weight_result = autovivify_list() for w, c in zip(left_weights, left_cluster_labels): left_weight_result[c].append(w) for w, c in zip(right_weights, right_cluster_labels): right_weight_result[c].append(w) left_weight = [0.] * 100 right_weight = [0.] * 100 for c, weights in left_weight_result.items(): left_weight[c] = sum(weights) for c, weights in right_weight_result.items(): right_weight[c] = sum(weights) left_emb = torch.tensor(left_emb, dtype=torch.float).unsqueeze(0) left_weight = weight_normalize(left_weight, min_v=1e-3, max_v=0.2) left_weight = torch.tensor(left_weight, dtype=torch.float).unsqueeze(0) right_emb = torch.tensor(right_emb, dtype=torch.float).unsqueeze(0) right_weight = weight_normalize(right_weight, min_v=1e-3, max_v=0.2) right_weight = torch.tensor( right_weight, dtype=torch.float).unsqueeze(0) return left_emb, left_weight, right_emb, right_weight
def sort_expanding_patterns_by_meb(policy, state, storage, num=100): """ use meb function to filter top_num patterns (with weights) :param storage: :param state: :param num: (Default value = 100) """ # all_pos = len(state.top) + len(state.pos_seeds) patterns = [] for p, (df, pos_matched, neg_matched) in state.extracted_patterns.items(): weight = rlogf(df, pos_matched, neg_matched) patterns.append((p, weight)) items = heapq.nlargest(num * 2, patterns, key=lambda x: x[1]) ps = [p for p, _ in items] probs, _ = policy.predict(state, ps) pattern_probs = [(p, w) for p, w in zip(ps, probs)] items = heapq.nlargest(num, pattern_probs, key=lambda x: x[1]) patterns = [p[0] for p in pattern_probs] pattern_weights = [p[1] for p in pattern_probs] pattern_weights = weight_normalize(pattern_weights) return patterns, pattern_weights
def get_patternset_embedding(self, patterns_weights): patterns = [p[0] for p in patterns_weights] weights = [p[1] for p in patterns_weights] weights = weight_normalize(weights) weights = torch.from_numpy(weights).unsqueeze(0).float() embeddings = self.get_direct_embeddings(patterns) entity_embedding = torch.mm(weights, embeddings) return entity_embedding.squeeze(0)
def get_adpe(self, storage, state, core_entities, context_count): adaptions = state.adaptions if state else None patterns, weights = get_adpe(storage, core_entities, context_count=context_count, adaptions=adaptions) weights = weight_normalize(weights) result = (patterns, weights) return [result]
def get_dpe(self, storage, state, entities, context_count): pattern_weights = [] for entity in entities: patterns, weights = get_adpe(storage, [entity], context_count=context_count, adaptions=state.adaptions) weights = weight_normalize(weights) result = (patterns, weights) pattern_weights.append(result) return pattern_weights
def predict(self, env, state, actions): weights = weight_normalize(state.priors) return weights.tolist(), 0