escuccim

import numpy as np
from scipy import stats

## Cluster purity
def purity(truth, pred):
    cluster_purities = []
    # loop through clusters and calculate purity for each
    for pred_cluster in np.unique(pred):
        filter_ = pred == pred_cluster
        gt_partition = truth[filter_]

escuccim

# depends on my FPTree algorithm - https://gist.github.com/escuccim/dc9aa979d54af69234f508538af7ee1a
# to mine the initial set of candidates for the pool

import numpy as np
import pandas as pd
import random
from itertools import combinations

class PatternFusion():
    def __init__(self, min_support=10):

escuccim

# DB is dictionary with tuple of pattern as key and support as value
# P1 and P2 are lists or arrays of the keys to compare
# this will only work if one of P1 and P2 is a subset of the other
def pattern_distance(P1, P2, db):
    P1_support = db[tuple(P1)]
    P2_support = db[tuple(P2)]
        
    # if P1 is a subset of P2 then we just use their supports
    if set(P1).issubset(set(P2)):
        return 1 - (P2_support / P1_support)

escuccim

class FPTree():
    def __init__(self, min_support=2, min_length=1, max_length=None):
        self.min_support = min_support
        self.min_length = min_length
        self.max_length = max_length
        
    # class for a tree node with a name, count, parent and children
    # taken from : https://adataanalyst.com/machine-learning/fp-growth-algorithm-python-3/
    class treeNode:
        def __init__(self, nameValue, numOccur, parentNode):

escuccim

# dose: daily dose
# halflife: half-life in hours
# start_level: initial blood levels
# days: days to model
def blood_level(dose, halflife, start_level=0, days=200):
    # starting level = 0
    level_0 = start_level
    # level after first dose = dose
    level = dose + start_level
    

escuccim

import tensorflow as tf


def bbox_overlap_iou(bboxes1, bboxes2):
    """
    Args:
        bboxes1: shape (total_bboxes1, 4)
            with x1, y1, x2, y2 point order.
        bboxes2: shape (total_bboxes2, 4)
            with x1, y1, x2, y2 point order.

escuccim

def duplicate_columns(frame):
    groups = frame.columns.to_series().groupby(frame.dtypes).groups
    dups = []

    for t, v in groups.items():

        cs = frame[v].columns
        vs = frame[v]
        lcs = len(cs)

escuccim

# plot feature importance for sklearn decision trees    
def feature_importance(forest, X_train, display_results=True):
    ranked_list = []
    zero_features = []
    
    importances = forest.feature_importances_

    indices = np.argsort(importances)[::-1]
    
    if display_results:

escuccim

# mean encoding
means = X_tr.groupby(col).target.mean()

train_new[col+'_target_mean'] = train_new[col].map(means)
val_new[col+'_target_mean'] = val_new[col].map(means)

escuccim

# this works just like "unlist" in R
def flatten(l):
  out = []
  for item in l:
    if isinstance(item, (list, tuple)):
        out.extend(flatten(item))
    else:
        out.append(item)
  return out