es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Necesito usar aplicar o emisión y enmascaramiento para iterar sobre un DataFrame.

11 Jul, 2023 Programación

Tengo un marco de datos que necesito recorrer. Quiero usar tanto apply como broadcasting y enmascaramiento. Este es el pseudocódigo que estoy tratando de mejorar.

2 El algoritmo
Algoritmo 1: El algoritmo
Inicializa la población (de tamaño n) de forma uniformemente aleatoria, respetando los límites;
mientras no se complete un número predefinido de iteraciones, haz lo siguiente:
Establece los parámetros aleatorios (dos parámetros independientes para cada una de las d variables); encuentra los mejores y peores vectores en la población;
para cada vector en la población, crea un nuevo vector usando el vector actual, el mejor vector, el peor vector y los parámetros aleatorios;
si el nuevo vector es al menos tan bueno como el vector actual, entonces el vector actual es igual al nuevo vector;

Este es el código que tengo hasta ahora.

import numpy as np
import pandas as pd

df = pd.DataFrame(np.random.uniform(-5.0, 10.0, size=(20, 5)), columns=list(‘ABCDE’))
pd.set_option(‘display.max_columns’, 500)

df

Sección while del pseudocódigo

f_func = np.square(df).sum(axis=1)
final_func = np.square(f_func)
xti_best = final_func.idxmin()
xti_worst = final_func.idxmax()
print(final_func)
print(df.head())
print(df.tail())

*# Sección for loop del pseudocódigo
#for row in df.iterrows():

implementar ecuación de la tarea

#definir operaciones de matrices
#xi_new = row.to_numpy() + np.random.uniform(0, 1, size=(1, 5)) * (df.iloc[xti_best].values – np.absolute(row.to_numpy())) – np.random.uniform(0, 1, size=(1, 5)) * (df.iloc[xti_worst].values – np.absolute(row.to_numpy()))
#print(xi_new)*

df2 = df.apply(lambda row: 0 if row == 0 else row + np.random.uniform(0, 1, size=(1, 5)) * (df.iloc[xti_best].values – np.absolute(axis=1)))
print(df2)

La fórmula que estoy intentando usar para xi_new es:

xi_new = xi_actual + valor aleatorio entre 0 y 1 (xti_mejor – abs(xi_actual)) – valor aleatorio (xti_peor – abs(xi_actual))

Tags:  , , , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Para mejorar el código anterior, podemos utilizar directamente la transmisión (broadcasting) y el enmascaramiento (masking) de numpy en lugar de usar apply e iterar sobre filas. La transmisión en numpy nos permite realizar operaciones elemento a elemento entre arrays de diferentes formas, lo que puede acelerar considerablemente el código. El enmascaramiento en numpy nos permite filtrar elementos en función de alguna condición.

    Aquí está el código mejorado:

    import numpy as np
import pandas as pd

# inicializar la población
df = pd.DataFrame(np.random.uniform(-5.0, 10.0, size=(20, 5)), columns=list('ABCDE'))

# establecer el número de iteraciones
n_iters = 100

for i in range(n_iters):

    # evaluar la función de aptitud para cada individuo
    f = np.square(df).sum(axis=1)

    # encontrar a los mejores y peores individuos
    x_best = df.iloc[f.idxmin()]
    x_worst = df.iloc[f.idxmax()]

    # crear la nueva población utilizando la transmisión y el enmascaramiento de numpy
    r1 = np.random.uniform(0, 1, size=(20, 5))
    r2 = np.random.uniform(0, 1, size=(20, 5))
    df_new = df + r1 * (x_best.to_numpy() - np.abs(df.to_numpy())) - r2 * (x_worst.to_numpy() - np.abs(df.to_numpy()))
    mask = np.greater(np.square(df_new).sum(axis=1), np.square(df).sum(axis=1))
    df = np.where(mask[:, None], df, df_new)

# imprimir la población final
print(df)

    Explicación:

    • Inicializamos la población utilizando pandas DataFrame y numpy random.uniform.
    • Establecemos el número de iteraciones que se realizarán en el algoritmo.
    • En cada iteración, evaluamos la función de aptitud para cada individuo en la población utilizando numpy square y sum.
    • Encontramos a los mejores y peores individuos utilizando pandas idxmin y idxmax.
    • Creamos la nueva población utilizando la transmisión y el enmascaramiento de numpy. Creamos dos matrices aleatorias r1 y r2 de tamaño (20, 5) utilizando numpy random.uniform. Luego utilizamos estas matrices para calcular la nueva población utilizando la fórmula dada en la tarea. Finalmente, utilizamos numpy greater y where para filtrar los individuos que no son al menos tan buenos como el individuo actual.
    • Repetimos los pasos anteriores para el número especificado de iteraciones e imprimimos la población final.

    Este código es mucho más eficiente que el código original ya que no utiliza apply ni itera sobre filas. Utiliza el poder de la transmisión y el enmascaramiento de numpy para realizar operaciones elemento a elemento y filtrado. Este código también se ajusta mejor a los data frames más grandes ya que las operaciones de numpy están optimizadas para arrays grandes.

Comments are closed.