Ishigami's questions

Tenho um dataframe Pandas que registra o desempenho dos alunos em exames de diferentes turmas e ele se parece com:

Class_ID   Class_size   Student_Number   IQ   Hours   Score   Place
1          3            1                101  10      98      1
1          3            2                99   19      80      3
1          3            3                130  3       95      2
2          5            1                93   5       50      5
2          5            2                103  9       88      3
2          5            3                112  12      99      2
2          5            4                200  10      100     1
2          5            5                90   19      78      4
3          2            1                100  12      84      2
3          2            2                102  13      88      1

e eu gostaria de converter o formato longo acima em formato largo, usando Student_Numberas columnse Class_ID, Class_sizeas index, com a última coluna Topsendo o aluno que chega primeiro naquela classe, então o resultado desejado se parece com:

Class_ID Class_size IQ_1 IQ_2 IQ_3 IQ_4 IQ_5 Hours_1 Hours_2 Hours_3 Hours_4 Hours_5 Score_1 Score_2 Score_3 Score_4 Score_5 Top
1        1          101  99   130  NaN  NaN  10      19      3       NaN     NaN     98      80      95      NaN     NaN     1
2        5          93   103  112  200  90   5       9       12      10      19      50      88      99      100     78      4
3        2          100  102  NaN  NaN  NaN  12      13      NaN     NaN     NaN     84      88      NaN     NaN     NaN     2

E aqui está o que eu tentei:

out = df.pivot_table(index=['Class_ID', 'Class_size'],
                     columns='Student_Number',
                     values=['IQ', 'Hours', 'Score'])
out.columns = [f'{x}_{y}' for x,y in out.columns]
out_dummy = out.reset_index()
df_wide = out_dummy

No entanto, não tenho ideia de como criar a última coluna Top. E também, o código acima parece ser bem lento, e como meu dataframe original é bem grande (~300.000 linhas), gostaria de perguntar se há alguma maneira mais rápida de fazer isso também. Muito obrigado antecipadamente.

Tenho um Pandas DataFrame que se parece com:

ID  result
1   [.1,.5]
2   [.4,-.2,-.3,.1,0]
3   [0,.1,.6]

Como posso dividir esta coluna de listas em duas colunas?

Resultado desejado:

ID  result_1 result_2 result_3 result_4 result_5
1   .1       .5       NaN      NaN      NaN
2   .4       -.2      -.3      .1       0
3   0        .1       .6       NaN      NaN

Eu pesquisei um pouco e encontrei isto: Dividir uma coluna de listas do Pandas em várias colunas

mas isso só parece se aplicar a listas com um número constante de elementos.

Muito obrigado antecipadamente.

Eu tenho um dataframe Pandas que se parece com

df = pd.DataFrame([['John', 'A', '1/1/2017', '10'],
                   ['John', 'A', '2/2/2017', '15'],
                   ['John', 'A', '2/2/2017', '20'],
                   ['John', 'A', '3/3/2017', '30'],
                   ['Sue', 'B', '1/1/2017', '10'],
                   ['Sue', 'B', '2/2/2017', '15'],
                   ['Sue', 'B', '3/2/2017', '20'],
                   ['Sue', 'B', '3/3/2017', '7'],
                   ['Sue', 'B', '4/4/2017', '20']],
                  columns=['Customer', 'Group', 'Deposit_Date', 'DPD'])

E eu quero criar uma nova linha chamada PreviousMean. Esta coluna é a média do ano até a data de DPD para aquele cliente. ou seja, inclui todos os DPDs até, mas não incluindo, as linhas que correspondem à data de depósito atual. Se nenhum registro anterior existia, então é nulo ou 0.

Então o resultado desejado parece ser

  Customer  Group  Deposit_Date  DPD  PreviousMean
0     John      A    2017-01-01   10           NaN
1     John      A    2017-02-02   15          10.0
2     John      A    2017-02-02   20          10.0
3     John      A    2017-03-03   30          15.0
4      Sue      B    2017-01-01   10           NaN
5      Sue      B    2017-02-02   15          10.0
6      Sue      B    2017-03-02   20          12.5
7      Sue      B    2017-03-03    7          15.0
8      Sue      B    2017-04-04   20          13.0

E depois de alguma pesquisa no site e na internet aqui está uma solução:

df['PreviousMean'] = df.apply(
    lambda x: df[(df.Customer == x.Customer) & 
                 (df.Group == x.Group) & 
                 (df.Deposit_Date < x.Deposit_Date)].DPD.mean(), 
axis=1)

E funciona bem. No entanto, meu dataframe real é muito maior (~1 milhão de linhas) e o código acima é muito lento.

Já fiz uma pergunta semelhante antes: Pandas groupby transforma média com data antes da linha atual para um enorme dataframe

exceto que desta vez o groupby é feito em duas colunas e, portanto, as soluções não funcionam e eu falhei em tentar generalizá-lo. Existe alguma maneira melhor de fazer isso? Obrigado

Eu tenho um dataframe Pandas que se parece com

df = pd.DataFrame([['John', '1/1/2017','10'],
                   ['John', '2/2/2017','15'],
                   ['John', '2/2/2017','20'],
                   ['John', '3/3/2017','30'],
                   ['Sue', '1/1/2017','10'],
                   ['Sue', '2/2/2017','15'],
                   ['Sue', '3/2/2017','20'],
                   ['Sue', '3/3/2017','7'],
                   ['Sue', '4/4/2017','20']],
                   columns=['Customer', 'Deposit_Date','DPD'])

E eu quero criar uma nova linha chamada PreviousMean. Esta coluna é a média do ano até a data de DPD para aquele cliente. ou seja, inclui todos os DPDs até, mas não incluindo, as linhas que correspondem à data de depósito atual. Se nenhum registro anterior existia, então é nulo ou 0.

Então o resultado desejado parece ser

  Customer Deposit_Date  DPD  PreviousMean
0     John   2017-01-01   10           NaN
1     John   2017-02-02   15          10.0
2     John   2017-02-02   20          10.0
3     John   2017-03-03   30          15.0
4      Sue   2017-01-01   10           NaN
5      Sue   2017-02-02   15          10.0
6      Sue   2017-03-02   20          12.5
7      Sue   2017-03-03    7          15.0
8      Sue   2017-04-04   20          13.0

E depois de alguma pesquisa no site e na internet aqui está uma solução:

df['PreviousMean'] = df.apply(
    lambda x: df[(df.Customer == x.Customer) & (df.Deposit_Date < x.Deposit_Date)].DPD.mean(), 
axis=1)

E funciona bem. No entanto, meu datafram real é muito maior (~1 milhão de linhas) e o código acima é muito lento. Existe alguma maneira melhor de fazer isso? Obrigado

Tenho uma lista com matrizes NumPy como elementos que se parece com isto:

[array([ 0.2, -2.3,  5.3]),
 array([-1.6, -1.7,  0.3]),
 array([ 2.4, -0.2, -3.0]),
 array([-4.1, -2.3, -2.7])]

e eu quero convertê-lo em 3 listas, cada uma com elementos das colunas da lista acima. Então o resultado desejado parece

list1 = [0.2, -1.6, 2.4, -4.1]
list2 = [-2.3, -1.7, -0.2, -2.3]
list3 = [5.3, 0.3, -3.0, -2.7]

Não tenho certeza se isso é mais adequado para troca de pilha matemática ou estouro de pilha, mas como as provas matemáticas parecem boas para mim, suspeito que o problema seja o código e, portanto, vou publicá-lo aqui:

A primeira fórmula (fórmula 1) é direta por definição:

e aqui está meu código para a fórmula 1:

import scipy.integrate as integrate
from scipy.integrate import nquad
from scipy.stats import norm
import math

def normalcdf(x):
    return (1+math.erf(x/math.sqrt(2)))/2

def normalpdf(x): 
    return math.exp(-x*x/2)/math.sqrt(2*math.pi)

def integrand12345(x1,x2,x3,x4,x5,theta1,theta2,theta3,theta4,theta5):
  return normalpdf(x1 - theta1) * normalpdf(x2 - theta2) * normalpdf(x3 - theta3) * normalpdf(x4 - theta4) * normalpdf(x5 - theta5)

def range_x1(theta1,theta2,theta3,theta4,theta5):
  return [-np.inf, np.inf]

def range_x2(x1,theta1,theta2,theta3,theta4,theta5):
  return [x1, np.inf]

def range_x3(x2,x1,theta1,theta2,theta3,theta4,theta5):
  return [x2, np.inf] 

def range_x4(x3,x2,x1,theta1,theta2,theta3,theta4,theta5):
  return [x3, np.inf] 

def range_x5(x4,x3,x2,x1,theta1,theta2,theta3,theta4,theta5):
  return [x4, np.inf]

def pi_12345(theta1,theta2,theta3,theta4,theta5):
  return (nquad(integrand12345, [range_x5, range_x4, range_x3, range_x2, range_x1], args=(theta1,theta2,theta3,theta4,theta5)))[0]

A segunda fórmula (fórmula 2) usa integração dupla: e aqui está o código da fórmula 2:

def integrandforpi_12(x1, x2, t1, t2, *theta): 
  prod = 1
  for ti in theta:
    prod = prod * (1 - normalcdf(x2 - ti))
  return prod * normalpdf(x1 - t1) * normalpdf(x2 - t2)

def range_x1(t1, t2, *theta):
  return [-np.inf, np.inf]

def range_x2(x1, t1, t2, *theta):
  return [x1, np.inf]

def pi_12(t1, t2, *theta):
  return (nquad(integrandforpi_12, [range_x2, range_x1], args=(t1, t2, *theta)))[0]

Minha terceira fórmula (fórmula 3) é baseada no teorema de Bayes:

e meu código para a fórmula 3 é:

def integrandforpi_i(xi, ti, *theta):
  prod = 1
  for t in theta:
    prod = prod * (1 - normalcdf(xi - t))
  return prod * normalpdf(xi - ti)

def pi_i(ti, *theta):
  return integrate.quad(integrandforpi_i, -np.inf, np.inf, args=(ti, *theta))[0]

Então pi_i calcula a probabilidade de que X_i seja o menor entre os theta_i.

No entanto, quando executo meu código usando as 3 fórmulas diferentes, todas elas dão respostas diferentes e não tenho ideia do porquê. Não tenho certeza se há uma falha na minha derivação da fórmula ou se há um erro no meu código. Qualquer ajuda seria apreciada.

Aqui está um exemplo:

t1,t2,t3,t4,t5 = 0.83720022,0.61704171,1.21121701,0,1.52334078

p12345 = pi_12345(t1,t2,t3,t4,t5)
p12354 = pi_12345(t1,t2,t3,t5,t4)
p12435 = pi_12345(t1,t2,t4,t3,t5)
p12453 = pi_12345(t1,t2,t4,t5,t3)
p12534 = pi_12345(t1,t2,t5,t3,t4)
p12543 = pi_12345(t1,t2,t5,t4,t3)

print('p12345=',p12345)
print('p12354=',p12354)
print('p12435=',p12435)
print('p12453=',p12453)
print('p12534=',p12534)
print('p12543=',p12543)

print('formula 1 gives', p12345+p12354+p12435+p12453+p12534+p12543)

print('formula 2 gives', pi_12(t1,t2,t3,t4,t5))

print('formula 3 gives', pi_i(t2,t3,t4,t5) * pi_i(t1,t2,t3,t4,t5))

e a saída é

p12345= 0.0027679276698449086
p12354= 0.008209750140618218
p12435= 0.0016182955786153714
p12453= 0.001921206801273682
p12534= 0.009675713474375739
p12543= 0.003904872716765966
formula 1 gives 0.028097766381493885
formula 2 gives 0.21897431741874426
formula 3 gives 0.0418669679120933

Observação: A Fórmula 1 é extremamente lenta, leva cerca de 3 horas para rodar no meu pobre e velho laptop. As Fórmulas 2 e 3 são instantâneas.

Eu tenho um dataframe do pandas que se parece com

Race_ID   Date           Student_ID      Rank  
1         1/1/2023       1               100-20     
1         1/1/2023       2               40-10       
2         11/9/2022      3               100-5     
3         17/4/2022      5               100-0     
3         17/4/2022      2               4-0     
4         1/3/2022       1               10-5        

onde o tipo de dados Ranké string. Quero extrair os números Ranke somá-los, para que o resultado desejado seja assim:

Race_ID   Date           Student_ID      Rank      New_column
1         1/1/2023       1               100-20    80 
1         1/1/2023       2               40-10     30  
2         11/9/2022      3               100-5     95
3         17/4/2022      5               100-0     100
3         17/4/2022      2               4-0       4
4         1/3/2022       1               10-5      5 

Eu tenho um dataframe do Pandas que se parece com

Race_ID   Date           Student_ID      Rank  
1         1/1/2023       1               3     
1         1/1/2023       2               8     
1         1/1/2023       3               0     
1         1/1/2023       4               4     
2         11/9/2022      1               2     
2         11/9/2022      2               3     
2         11/9/2022      3               9     
3         17/4/2022      5               0     
3         17/4/2022      2               1     
3         17/4/2022      3               2     
3         17/4/2022      4               5     
4         1/3/2022       1               6     
4         1/3/2022       2               2     
5         1/1/2021       1               0     
5         1/1/2021       2               3     
5         1/1/2021       3               1     

E quero adicionar uma nova coluna min>0cujo valor mínimo de Rankgroupby Race_IDseja maior que 0, para que o resultado desejado seja semelhante

Race_ID   Date           Student_ID      Rank  min>0  
1         1/1/2023       1               3     3
1         1/1/2023       2               8     3
1         1/1/2023       3               0     3
1         1/1/2023       4               4     3
2         11/9/2022      1               2     2
2         11/9/2022      2               3     2
2         11/9/2022      3               9     2
3         17/4/2022      5               0     1
3         17/4/2022      2               1     1
3         17/4/2022      3               2     1
3         17/4/2022      4               5     1
4         1/3/2022       1               6     2
4         1/3/2022       2               2     2
5         1/1/2021       1               0     1
5         1/1/2021       2               3     1
5         1/1/2021       3               1     1

Eu sei groupby, transform('min')mas não sei como incluir a condição> 0.

Eu tenho um dataframe panads do wiki

Outlook  Temperature    Humidity    Wind    Play
Sunny    Hot            High        False   No
Sunny    Hot            High        True    No
Overcast Hot            High        False   Yes
Rainy    Mild           High        False   Yes
Rainy    Cool           Normal      False   Yes
Rainy    Cool           Normal      True    No
Overcast Cool           Normal      True    Yes
Sunny    Mild           High        False   No
Sunny    Cool           Normal      False   Yes
Rainy    Mild           Normal      False   Yes
Sunny    Mild           Normal      False   Yes
Overcast Mild           High        True    Yes
Overcast Hot            Normal      False   Yes
Rainy    Mild           High        True    No

e eu quero ver se outlooké sunny/ overcast/ rainy, quantas vezes eles vão jogar e então calcular a entropia de Shannon para cada um dos resultados, então o resultado desejado se parece com

Outlook     Yes No  Count of each group Entropy
sunny       2   3   5                   0.971
overcast    4   0   4                   0.000
rainy       3   2   5                   0.971

onde Entropyé dado pela fórmula -((sim/contagem)log_2(sim/contagem) + (não/contagem)log_2(não/contagem))

Por exemplo, a entropia para sunnyé -((2/5)log_2(2/5)+(3/5)log_2(3/5))=0,971

Eu tenho um dataframe dfque se parece com:

Race_ID   Date           Student_ID      Rank  Student_Name 
1         1/1/2023       1               3     Ryan
1         1/1/2023       NaN             2     Mary
1         1/1/2023       3               1     Tony
1         1/1/2023       4               4     Chris
2         11/9/2022      1               2     Ryan
2         11/9/2022      NaN             3     Mary
2         11/9/2022      3               1     Tony
3         17/4/2022      5               4     Josh
3         17/4/2022      NaN             1     Mary
3         17/4/2022      3               2     Tony
3         17/4/2022      4               3     Chris
4         1/3/2022       1               1     Ryan
4         1/3/2022       NaN             2     Mary
5         1/1/2021       1               2     Ryan
5         1/1/2021       NaN             3     Mary
5         1/1/2021       3               1     Tony

Falta o Student_ID de Mary. No entanto, tenho outro dataframe studentListque se parece com

Studnet_ID   Student_Name
1            Ryan
2            Mary
3            Tony
4            Chris
5            Josh
6            David
7            Evan

que eu quero usar para preencher a NaNcoluna Student_IDem df. Existe alguma maneira rápida de fazer isso? Obrigado.