Mam dwie ramki danych (df_1 i df_2) i kilka zmiennych (A, B, C):

df_1 = pd.DataFrame({'O' : [1,2,3], 'M' : [2,8,3]})
df_2 = pd.DataFrame({'O' : [1,1,1, 2,2,2, 3,3,3],
                     'M' : [9,2,4, 6,7,8, 5,3,4],
                     'X' : [2,4,6, 4,8,7, 3,1,9],
                     'Y' : [3,6,1, 4,6,5, 1,0,7],
                     'Z' : [2,4,8, 3,5,4, 7,5,1]})

Mam poniżej algorytm, który używa A, B, C do obliczenia wyniku (S) dla każdego wiersza w df_2. Znajduje wiersz w df_2 z najwyższym wynikiem (S). Porównuje wiersz z najwyższą punktacją w df_2 z df_1 i oblicza p_hat, miarę podobieństwa między nimi:

M_G = df_1.M
df_1 = df_1.set_index('O')
        
A = 1
B = 1
C = 1
 
# Score
df_2['S'] = df_2['X']*A + df_2['Y']*B + df_2['Z']*C
        
# Top score
df_Sort = df_2.sort_values(['S', 'X', 'M'], ascending=[False, True, True])
df_O    = df_Sort.set_index('O')
M_Top   = df_O[~df_O.index.duplicated(keep='first')].M
M_Top   = M_Top.sort_index()
        
# Compare the top scoring row for each O to df_1
df_1_M = df_1.M
df_1_M = df_1_M.sort_index()
df_1_R = df_1_M.reindex(M_Top.index)
T_N_T  = M_Top == df_1_R

# Record the results for the given values of A,B,C
df_Res = pd.DataFrame({'it_is':T_N_T}) # is this row of df_1 the same as this row of M_Top?
        
# p_hat =         TP / (TP + FP)
p_hat = df_Res.sum() / len(df_Res.index)

Dla wartości A, B, C w przykładzie daje to p_hat = 0,333. Chciałbym znaleźć wartości A, B, C, które dają maksymalną możliwą wartość p_hat. Chciałbym użyć algorytmu optymalizacji, aby upewnić się, że otrzymam maksymalną wartość.

Wykres jest dla C = 2:

tutaj wprowadź opis obrazu Jak mogę znaleźć maksymalne p_hat proszę?

0
R. Cox 27 sierpień 2020, 19:54

3 odpowiedzi

Najlepsza odpowiedź

Znalazłem sposób, aby to zrobić za pomocą globalnej optymalizacji brutalnej siły:

from scipy.optimize import brute

df_1 = pd.DataFrame({'O' : [1,2,3], 'M' : [2,8,3]})

df_2 = pd.DataFrame({'O' : [1,1,1, 2,2,2, 3,3,3],
                     'M' : [9,2,4, 6,7,8, 5,3,4],
                     'X' : [2,4,6, 4,8,7, 3,1,9],
                     'Y' : [3,6,1, 4,6,5, 1,0,7],
                     'Z' : [2,4,8, 3,5,4, 7,5,1]})



# Range
min_ = -2
max_ = 2
step = .5
ran_ge = slice(min_, max_+step, step)
ranges = (ran_ge,ran_ge,ran_ge)

# Params
params = (df_1, df_2)

# Index
df_1 = df_1.set_index('O')
df_1_M = df_1.M
df_1_M = df_1_M.sort_index()

# Fun
def fun(z, *params):
    A,B,C = z
        
    # Score
    df_2['S'] = df_2['X']*A + df_2['Y']*B + df_2['Z']*C
    
    # Top score
    df_Sort = df_2.sort_values(['S', 'X', 'M'], ascending=[False, True, True])
    df_O    = df_Sort.set_index('O')
    M_Top   = df_O[~df_O.index.duplicated(keep='first')].M
    M_Top   = M_Top.sort_index()
        
    # Compare the top scoring row for each O to df_1
    df_1_R = df_1_M.reindex(M_Top.index) # Nan
    T_N_T  = M_Top == df_1_R

    # Record the results for the given values of A,B,C
    df_Res = pd.DataFrame({'it_is':T_N_T}) # is this row of df_1 the same as this row of M_Top?
        
    # p_hat =         TP / (TP + FP)
    p_hat = df_Res.sum() / len(df_Res.index)
    
    return -p_hat

# Brute
resbrute = brute(fun,
                 ranges,
                 args=params,
                 full_output=True,
                 finish=None)

print('Global maximum ',                   resbrute[0])
print('Function value at global maximum ',-resbrute[1])

To daje:

Global maximum  [-2.   0.5  1.5]
Function value at global maximum  0.6666666666666666
0
R. Cox 7 wrzesień 2020, 15:40

Myślę, że możesz skorzystać z pakietu Optuna, jest bardzo łatwy w użyciu. Definiujesz funkcję celu, w której obliczasz zmienną, którą chcesz zoptymalizować w dowolny sposób, tworzysz dla niej obiekt study, a Optuna w zasadzie zajmuje się resztą.

Mały przykład łatwej funkcji 2D:

import optuna

def optimize_me(trial):
    x = trial.suggest_uniform('x', -10, 10)
    y = trial.suggest_uniform('y', -10, 10)
    return ((y - 1) ** 2) + ((x + 2) ** 2)

study = optuna.create_study()
study.optimize(optimize_me, n_trials = 10)

Więcej informacji o Optunie znajdziesz tutaj

Używam tego głównie do optymalizacji parametrów hiperpracy dla RNN, jest to bardzo wydajny pakiet.

0
Rouben 2 wrzesień 2020, 14:26

Lub korzystając z globalnej, ewolucyjnej optymalizacji: (kod poprawiony przez @Aviv Yaniv)

from scipy.optimize import differential_evolution

df_1 = pd.DataFrame({'O' : [1,2,3], 'M' : [2,8,3]})

df_2 = pd.DataFrame({'O' : [1,1,1, 2,2,2, 3,3,3],
                     'M' : [9,2,4, 6,7,8, 5,3,4],
                     'X' : [2,4,6, 4,8,7, 3,1,9],
                     'Y' : [3,6,1, 4,6,5, 1,0,7],
                     'Z' : [2,4,8, 3,5,4, 7,5,1]})

# Index
df_1 = df_1.set_index('O')
df_1_M = df_1.M
df_1_M = df_1_M.sort_index()

# Fun
def fun(z, *params):
    A,B,C = z
        
    # Score
    df_2['S'] = df_2['X']*A + df_2['Y']*B + df_2['Z']*C
    
    # Top score
    df_Sort = df_2.sort_values(['S', 'X', 'M'], ascending=[False, True, True])
    df_O    = df_Sort.set_index('O')
    M_Top   = df_O[~df_O.index.duplicated(keep='first')].M
    M_Top   = M_Top.sort_index()
        
    # Compare the top scoring row for each O to df_1
    df_1_R = df_1_M.reindex(M_Top.index) # Nan
    T_N_T  = M_Top == df_1_R

    # Record the results for the given values of A,B,C
    df_Res = pd.DataFrame({'it_is':T_N_T}) # is this row of df_1 the same as this row of M_Top?
        
    # p_hat =         TP / (TP + FP)
    p_hat = df_Res.sum() / len(df_Res.index)
    
    print(z)
    return -p_hat[0]

# Bounds
min_ = -2
max_ = 2
ran_ge = (min_, max_)
bounds = [ran_ge,ran_ge,ran_ge]

# Params
params = (df_1, df_2)

# DE
DE = differential_evolution(fun, bounds, args=params)

print('Function value at global maximum ',-DE.fun)
0
R. Cox 13 wrzesień 2020, 11:05