utils.py

import torch
import numpy as np

def one_hot(y, num_class):         
    return torch.zeros((len(y), num_class)).scatter_(1, y.unsqueeze(1), 1)

def DBindex(cl_data_file):
    class_list = cl_data_file.keys()
    cl_num= len(class_list)
    cl_means = []
    stds = []
    DBs = []
    for cl in class_list:
        cl_means.append( np.mean(cl_data_file[cl], axis = 0) )
        stds.append( np.sqrt(np.mean( np.sum(np.square( cl_data_file[cl] - cl_means[-1]), axis = 1))))

    mu_i = np.tile( np.expand_dims( np.array(cl_means), axis = 0), (len(class_list),1,1) )
    mu_j = np.transpose(mu_i,(1,0,2))
    mdists = np.sqrt(np.sum(np.square(mu_i - mu_j), axis = 2))
    
    for i in range(cl_num):
        DBs.append( np.max([ (stds[i]+ stds[j])/mdists[i,j]  for j in range(cl_num) if j != i ]) )
    return np.mean(DBs)

def sparsity(cl_data_file):
    class_list = cl_data_file.keys()
    cl_sparsity = []
    for cl in class_list:
        cl_sparsity.append(np.mean([np.sum(x!=0) for x in cl_data_file[cl] ])  ) 

    return np.mean(cl_sparsity) 


def load_state_to_the_backbone(model, tmp):
    model_state = model.state_dict()
    tmp_state = tmp['state']
    for i in range(len(list(tmp_state.keys()))):
        model_key = list(model_state.keys())[i]
        tmp_key = list(tmp_state.keys())[i]
        #print('key:', model_key, tmp_key)
        if (model_state[model_key].size()== tmp_state[tmp_key].size()):
            #print('true')
            model_state[model_key] = tmp_state[tmp_key]
    model.load_state_dict(model_state)
    print('model loaded.')
    return