Este operador crea un nuevo conjunto de ejemplos a partir del conjunto de ejemplos de entrada, mostrando los resultados de las funciones de agregación arbitrarias (como SUM, COUNT, etc. conocidas del SQL). Antes de que los valores de las diferentes filas sean agregadas en una nueva fila, las filas pueden ser agrupadas por los valores de uno o varios atributos (similar a la conocida cláusula group by del SQL). En este caso se creará una nueva línea por cada grupo.

Tener en cuenta que se puede simular la conocida cláusula HAVING del SQL mediante un operador adicional ExampleFilter a continuación de éste.

Este operador construye nuevos atributos a partir de los atributos del Conjunto de Ejemplos de entrada (ExampleSet) y constantes arbitrarias. Los nombres de los nuevos atributos y sus descripciones de construcción se definen en el parámetro funtions. Los nombres de los atributos se pueden utilizar como bvariables en la descripción de construcciones. Cuando se evalúan las descripciones sobre cada ejemplo durante la aplicación de este operador, estas variables serán asignadas con los pesos de los atributos de los ejemplos.

Tener en cuenta que hay algunas restricciones para los nombres de los atributos para permitir que este
operador trabaje correctamente:

• No están permitidos los nombres de atributos que contienen paréntesis.
• No están permitidos los nombres de atributos que contienen espacios en blanco.
• Tampoco están permitidos los nombres de atributos con nombres de función u operador.
• Las constantes estándares (ver más adelante) se pueden utilizar, los nombres de atributos con nombres como “e” o “pi” no se permiten.

Si estas condiciones no se cumplen, se deben cambiar los nombres de antemano, por ejemplo con el operador Rename. Al cambiar varios atributos siguiendo un esquema determinado, puede resultar útil el operador Rename by Replacing.

Expresiones soportadas   

Las siguientes operaciones están soportadas:

• Adición: +
• Sustracción: -
• Multiplicación: *
• División: /
• Potencia: ^
• Módulo: %
• Menor que: <
• Mayor que: >
• Menor o Igual: <=
• Mayor o Igual: >=
• Igual: ==
• No Igual: !=
• Not Booleano: !
• And Booleano: &&
• Or Booleano: ||

Las siguientes funciones logarítmicas y exponenciales están soportadas:

• Logaritmo Natural: ln(x)
• Logaritmo Base 10: log(x)
• Logaritmo Dualis (Base 2): ld(x)
• Exponencial (e^x): exp(x)
• Potencia: pow(x,y)

Las siguientes funciones trigonométricas están soportadas:

• Seno: sin(x)
• Coseno: cos(x)
• Tangente: tan(x)
• Arco Seno: asin(x)
• Arco Coseno: acos(x)
• Arco Tangente: atan(x)
• Arco Tangente (con 2 parámetros): atan2(x,y)
• Seno Hiperbólico: sinh(x)
• Coseno Hiperbólico: cosh(x)
• Tangente Hiperbólica: tanh(x)
• Seno Hiperbólico Inverso: asinh(x)
• Coseno Hiperbólico Inverso: acosh(x)
• Tangente Hiperbólica Inversa: atanh(x)

Las siguientes funciones estadísticas están soportadas:

• Redondeo: round(x)
• Redondeo a p decimales: round(x,p)
• Piso: floor(x)
• Techo: ceil(x)
• Media: avg(x,y,z...)
• Mínimo: min(x,y,z...)
• Máximo: max(x,y,z...)

Las siguientes funciones misceláneas están soportadas:

• If-Then-Else: if(cond, evaluación-verdadero, evaluación-falso)
• Valor Absoluto: abs(x)
• Raíz Cuadrada: sqrt(x)
• Signo (devuelve el signo de un número): sgn(x)
• Número Aleatorio (entre 0 y 1): rand()
• Módulo (x % y): mod(x,y)
• Suma de k Números: sum(x,y,z...)
• Coeficientes Binomiales: binom(n, i)
• Número a Cadena: str(x)
• Cadena a Número: parse(x)
• Subcadena: cut(x, start, len)

Las siguientes funciones relacionadas a procesos están soportadas:

• Recuperar el valor de un parámetro: param("operator", "parameter")

Junto a los atributos y las operaciones y funciones antes mencionadas, este operador también soporta las constantes pi y e si esto se especifica por el parámetro correspondiente “use standard constants” (por defecto: true). También se pueden utilizar cadenas en las fórmulas (por ejemplo, en una fórmula ifcondicional), pero los valores de cadena tienen que estar encerrados entre comillas dobles (").

Ejemplos

a1+sin(a2*a3)
if (att1>5, att2*att3,-abs(att1))

Este operador agrega un ID de atributo al conjunto de ejemplos dado. Cada ejemplo es etiquetado con un número entero incremental. Si el conjunto de ejemplos ya contiene un id de atributo, el atributo anterior se elimina antes de agregar el nuevo.

YAGGA es el acrónimo de Yet Another Generating Genetic Algorithm. Su enfoque para generar nuevos atributos es diferente al original. La (generación) mutación puede hacer una de las siguientes cosas con diferentes probabilidades:

• Probabilidad p/4: Agrega un atributo recién generado al vector de características.
• Probabilidad p/4: Agrega un atributo original escogido de forma aleatoria al vector de características.
• Probabilidad p/2: Elimina un atributo al azar del vector de características.

Así se garantiza que la longitud del vector de características pueda aumentar y disminuir. En promedio se mantendrá su longitud original, a menos que los individuos más cortos o más largos resulten tener una mejor aptitud. Dado que este operador no contiene algoritmos para extraer características de series de valores, se limita solamente a conjuntos de ejemplos con atributos individuales. Para la extracción (automática) de características de series de valores, se debería utilizar el complemento de serie de valores para RapidMiner escrito por Ingo Mierswa. Está disponible en http://rapid-i.com.

Este operador realiza un análisis de componentes principales (PCA) utilizando la matriz de covarianza. El usuario puede especificar la cantidad de varianza a cubrir en los datos originales al retener el mejor número de componentes principales. El usuario también puede especificar manualmente el número de componentes principales. El operador genera un Modelo PCA. Con el operador ModelApplier se pueden transformar las características.

Este operador realiza los dos algoritmos deterministas greedy (codiciosos) de selección de características: selección forward (hacia delante) y eliminación backguard (hacia atrás). Sin embargo, se han añadido algunas mejoras a los algoritmos estándar, las que se describen a continuación:

Selección Forward

1. Crea una población inicial con n individuos donde n es la cantidad de atributos del conjunto de ejemplos de entrada. Cada individuo utilizará exactamente una de las características.
2. Evalúa los atributos del conjunto y selecciona sólo los k mejores.
3. Para cada uno de los k atributos del conjunto realiza: Si hay j atributos no utilizados, hace j copias del conjunto de atributos y agrega exactamente uno de los atributos anteriormente no utilizados al conjunto de atributos.
4. Mientras mejore la performance en las últimas p iteraciones se volverá al paso 2.

Eliminación Backward

1. Comienza con un conjunto de atributos con todas las características.
2. Evalúa todos atributos del conjunto y selecciona los k mejores.
3. Si hay j atributos utilizados, hace j copias del conjunto de atributos y elimina exactamente uno de los atributos utilizados anteriormente del conjunto de atributos.
4. Mientras mejore la performance en las últimas p iteraciones se volverá al paso 2.

El parámetro k puede ser especificado por el parámetro keep_best, el parámetro p puede ser especificado por el parámetro generations_without_improval. Estos parámetros tienen valores por defecto 1, lo que significa que se utilizan los algoritmos de selección estándar. Utilizando otros valores aumenta el tiempo de ejecución, pero podría ayudar a evitar extremos locales en la búsqueda del óptimo global.

Otro parámetro inusual es maximum_number_of_generations. Este parámetro limita el número de iteraciones a un máximo de selecciones/deselecciones de características. En combinación con generations_without_improval permite varios esquemas de selección diferentes (que se describen para la selección forward, la eliminación backward trabaja de forma análoga):

• maximum_number_of_generations = m y generations_without_improval = p: Selecciona un máximo de m características. La selección se detiene si no mejora la performance medida en las últimas p generaciones.
• maximum_number_of_generations = -1 y generations_without_improval = p: Trata de seleccionar nuevas características hasta que no haya mejoras en la performance medida en las últimas p generaciones.
• maximum_number_of_generations = m y generations_without_improval = -1: Selecciona un máximo de m características. La selección no se detiene hasta que todas las combinaciones con un máximo de m fueron probadas. Sin embargo, el resultado podría contener menos características que éstas.
• maximum_number_of_generations = -1 y generations_without_improval = -1: Prueba todas las combinaciones de atributos (fuerza bruta, esto podría tomar un tiempo muy largo y sólo debe aplicarse a los pequeños conjuntos de atributos).

Un algoritmo genético para la selección de características (mutación = conmutar entre habilitar y deshabilitar características, cruza = intercambiar características utilizadas). La selección se realiza haciendo

girar la ruleta. Los algoritmos genéticos son algoritmos de optimización/búsqueda de propósito general que son convenientes en caso de poco o ningún conocimiento del problema.

Un algoritmo genético funciona de la siguiente manera:

1. Genera una población inicial compuesta por population_size individuos. Cada atributo se habilita con una probabilidad p_initialize.
2. Para todos los individuos de la población:
   1. Realizan la mutación, es decir, definen los atributos utilizados o no utilizados con probabilidad p_mutation y viceversa.
   2. Seleccionan dos individuos de la población y realizan la cruza con probabilidad p_crossover. El tipo de cruza se puede seleccionar mediante crossover_type.
3. Realiza la selección, mapea todos los individuos a secciones de una ruleta, cuyo tamaño es proporcional a la aptitud del individuo y extrae population_size individuos al azar, en función de sus probabilidades.
4. Mientras mejora la aptitud, vuelve al paso 2.

Si el conjunto de ejemplos contiene atributos de series de valores con bloques de números, todo el bloque

Este operador selecciona cuáles atributos de un Conjunto de Ejemplos deben mantenerse, y cuáles deben ser eliminados. Por lo tanto, se pueden seleccionar diferentes tipos de filtros para el parámetro attribute filter
type y sólo se seleccionan los atributos que satisfacen este tipo de condición. El resto será eliminado del Conjunto de Ejemplos. Hay un conmutador global para invertir el resultado, de modo que todos los atributos
que han sido descartados inicialmente se mantendrán y viceversa. Para invertir la decisión, utilizar el parámetro invert selection.

Estos tipos están disponibles:

• all: Simplemente seleccionará todos los atributos
• single: Permite seleccionar un solo nombre de atributo. Este podría ser seleccionado de la lista del parámetro attribute si se conocen los meta datos.
• subset: Permite seleccionar varios atributos de una lista. No funcionará si los meta datos no están presentes. Cada atributo conocido se muestra en la lista y se podrían seleccionar.
• regular_expression: Permite especificar una expresión regular. Se seleccionará cada atributo cuyo nombre se corresponde con esta expresión. Las expresiones regulares son una herramienta muy potente pero necesitan una explicación detallada para los principiantes. Por favor consultar uno de los varios tutoriales disponibles en Internet para una descripción más detallada.
• value_type: Selecciona sólo los atributos de un determinado tipo. Tener en cuenta que los tipos son jerárquicos: Por ejemplo están los atributos denominados binominales, así como los polinominales.
• block_type: Similar a value_type, permite seleccionar los atributos en función de su tipo de bloque.
• no_missing_values: Seleccionará todos los atributos que no contengan un valor faltante en todos los ejemplos.
• numeric_value_filter: Seleccionará los atributos probando si todos los valores de sus ejemplos se corresponden con esta condición o si no son numéricos. La condición numérica se podría especificar escribiendola. Por ejemplo, la cadena de parámetro “> 6” mantendrá todos los atributos nominales y todos los atributos numéricos que tienen un valor mayor que 6 en cada ejemplo. Se puede realizar una combinación de condiciones: “> 6 && < 11” o “<= 5 || < 0”. Pero && y || no se deben mezclar.

Este operador selecciona todos los atributos que tienen un peso que satisface una determinada condición. Por ejemplo, sólo los atributos con un peso superior a min_weight deberían ser seleccionados. Este operador también es capaz de seleccionar los k atributos con mayor peso.

Este operador se puede utilizar para seleccionar un atributo (o un subconjunto de atributos) mediante la definición de una expresión regular para el nombre del atributo y aplica sus operadores internos al subconjunto resultante. Tener en cuenta que este operador también utilizará los atributos especiales, lo que lo hace necesario para todos los pasos de preprocesamiento que se deben realizar sobre los atributos especiales (y que normalmente no se realizan sobre los atributos especiales).

Este operador también es capaz de entregar los resultados adicionales del operador interno si así lo desea.

Posteriormente, los atributos originales restantes son agregados al conjunto de ejemplos resultante si el parámetro keep_subset_only se establece en false (por defecto).

Observe que este operador es muy potente y se puede utilizar para crear nuevos esquemas de preprocesamiento combinándolo con otros operadores de preprocesamiento. Sin embargo, hay dos restricciones importantes (entre algunas otras): en primer lugar, debido a que el resultado interno se combinará con el resto del conjunto de ejemplos de entrada, el número de ejemplos (puntos de datos) no se permite cambiar dentro del preprocesamiento del subconjunto. En segundo lugar, los cambios de rol de los atributos no serán entregados al exterior debido a que internamente todos los atributos especiales serán cambiados a regular para los operadores internos y los cambios de rol no se pueden entregar posteriormente.

Método de reducción de dimensionalidad basada en la Descomposición Singular de Valores (SVD).

Sustituye los valores faltantes en los ejemplos. Si un valor no está presente, se reemplaza por una de las funciones “minimum”, “maximum”, “average”, y “none”, las que se aplican a los valores de los atributos
que no faltan en el conjunto de ejemplos. “none” significa que no se sustituye el valor. La función se puede seleccionar usando la lista del parámetro columns. Si el nombre de un atributo aparece en esta lista como
una clave, el valor se utiliza como el nombre de la función. Si el nombre del atributo no está en la lista, se utiliza la función especificada por el parámetro default. Para los atributos nominales se utiliza la moda para
la media, es decir, el valor nominal que ocurre con mayor frecuencia en los datos. Para los atributos nominales y el tipo de reemplazo cero, se utiliza el primer valor nominal definido para este atributo. La reposición “valor” indica que se debe utilizar el parámetro definido por el usuario para la sustitución.

Este operador toma un Conjunto de Ejemplos como entrada y devuelve un nuevo Conjunto de Ejemplos incluyendo sólo los Ejemplos que cumplen con una condición.

Se pueden aplicar filtros arbitrarios especificando una implementación de Condition y una cadena de parámetro. Los usuarios pueden implementar sus propias condiciones escribiendo una subclase de la clase anterior e implementando un constructor de 2 argumentos que toma un Conjunto de Ejemplos y una cadena de parámetro. Esta cadena de parámetro se especifica mediante el parámetro parameter_string. En lugar de utilizar una de las condiciones predefinidas, los usuarios pueden definir sus propias implementaciones con el nombre de clase completamente adecuado.

Para attribute_value_condition la cadena de parámetro debe tener la forma atributo op valor, donde atributo es el nombre de un atributo, valor es un valor que el atributo puede tomar y op es uno de los operadores lógicos binarios similares a los conocidos de Java, por ejemplo, mayor o igual que (>=). Observar que se puede definir un OR lógico de varias condiciones con || y un AND lógico de dos condiciones con dos ampers and (&&) - o simplemente aplicando varios operadores ExampleFilter en una fila. Tener en cuenta también que para los atributos nominales se puede definir una expresión regular para el valor de posibles comprobaciones de igualdad y desigualdad.

Para unknown_attributes la cadena de parámetro debe estar vacía. Este filtro elimina todos los ejemplos que contienen atributos con valores faltantes o ilegales. Para unknown_label la cadena de parámetro también
debe estar vacía. Este filtro elimina todos los ejemplos con un valor de etiqueta desconocido.

Este operador se puede utilizar para cambiar el nombre de un atributo de un Conjunto de Ejemplos de entrada. Por favor, tener en cuenta que los nombres de atributos tienen que ser únicos. 

Aunque sea renombrado, un atributo mantiene su rol. Por ejemplo, si se cambia el nombre de un atributo “etiqueta” con rol label a “color”, el atributo resultante “color” todavía tendrá el rol label. Para cambiar un rol, consultar Set Role.

Este operador sustituye partes de los nombres de atributos (como espacios en blanco, paréntesis u otros caracteres no deseados) por un reemplazo especificado. El parámetro replace_what se puede definir como
una expresión regular (consultar el anexo del tutorial de RapidMiner para una descripción). El parámetro replace_by se puede definir como una cadena arbitraria. Las cadenas vacías también están permitidas. La
captura de grupos de la expresión regular definida se puede acceder con $1, $2, $3 ...

Este operador se puede utilizar para cambiar el rol de un atributo del Conjunto de Ejemplos de entrada. Si se desea cambiar el nombre del atributo se debe utilizar el operador Rename. 

El rol objetivo indica si el atributo es un atributo regular (utilizado por los operadores de aprendizaje) o un atributo especial (por ejemplo, un atributo label o id). Los siguientes tipos de atributos objetivos son posibles:

• regular: solo los atributos regulares se utilizan como variables de entrada para las tareas de aprendizaje.
• id: el atributo id para el conjunto de ejemplos.
• label: atributo objetivo para el aprendizaje.
• prediction: atributo pronosticado, es decir, las predicciones de un esquema de aprendizaje.
• cluster: indica la pertenencia a un grupo (cluster).
• weight: indica el peso del ejemplo.
• batch: indica la pertenencia a un lote (batch) de ejemplos.

Los usuarios también pueden definir tipos de atributos propios simplemente usando el nombre deseado.

¡Tener en cuenta que los roles tienen que ser únicos! Si se asigna un rol no regular por segunda vez, hará que el primer atributo sea eliminado del Conjunto de Ejemplos. Si se desea conservar este atributo, hay que cambiar primero su rol.

Este operador combina dos o más conjuntos dados de ejemplos agregando todos los ejemplos en una tabla de ejemplos que contiene todas las filas de datos. Tener en cuenta que la nueva tabla de ejemplos se
construye en la memoria y por lo tanto este operador podría no ser aplicable a la fusión de enormes tablas de conjuntos de datos de una base de datos. En ese caso se deberían utilizar otras herramientas de
preprocesamiento con tablas agregadas, unidas y fusionadas en una sola tabla que luego es utilizada por RapidMiner.

Todos los conjuntos de ejemplos de entrada deben proporcionar la misma estructura de atributos. Esto significa que todos los conjuntos de ejemplos deben tener la misma cantidad de atributos (especiales) y los
mismos nombres de atributos. Si esto es cierto este operador simplemente combina todos los conjuntos de ejemplos agregando todos los ejemplos de todas las tablas en un nuevo conjunto que luego se devuelve.

Construye la unión de dos conjuntos de ejemplos utilizando los atributos id de los conjuntos, es decir, los dos conjuntos ejemplos deben tener un atributo id donde el mismo id indica los mismos ejemplos. Si faltan
ejemplos se lanzará una excepción. El conjunto ejemplo resultante estará compuesto por la misma cantidad de ejemplos, pero el conjunto de la unión o la lista de la unión (según el ajuste del parámetro los atributos
dobles serán eliminados o renombrados) de ambos conjuntos de características. En caso de eliminar los atributos duplicados los valores de los atributos deben ser los mismos para los ejemplos de ambos conjuntos
de ejemplos, de lo contrario se lanzará una excepción.

Tener en cuenta que este control para atributos dobles sólo se aplicará para los atributos regulares. Los atributos especiales del segundo conjunto de ejemplos de entrada que no existen en el primer conjunto de
ejemplos simplemente serán agregados. Si ya existen, simplemente son omitidos.

Este operador ordena el Conjunto de Ejemplos dado de acuerdo a un solo atributo especificado por el parámetro attribute_name. Los ejemplos se clasifican según el orden natural de los valores de este atributo,
ya sea en dirección de aumento o en disminución, dependiendo de la configuración de sorting direction.

Este operador discretiza todos los atributos numéricos del conjunto de datos en atributos nominales. Esta discretización se realiza mediante intervalos de igual frecuencia, es decir, los umbrales de todos los intervalos se seleccionan de forma que todos los intervalos contengan la misma cantidad de valores numéricos. La cantidad de intervalos se especifica mediante un parámetro, o, de forma alternativa, se calcula la raíz cuadrada de la cantidad de ejemplos sin valores faltantes (calculado para cada atributo simple). Omite todos los atributos especiales, incluyendo la etiqueta. Observe que es posible obtener intervalos con diferentes cantidades de ejemplos. Esto puede ocurrir, si los valores de los atributos no son únicos, ya que el algoritmo no puede separar entre ejemplos con el mismo valor.

Este operador mapea los valores de todos los valores nominales a atributos binarios. Por ejemplo, si se transforma un atributo nominal con nombre “costos” y posibles valores nominales “bajo”, “moderado” y
“alto”, el resultado es un conjunto de 3 atributos binominales “costos = bajo”, “costos = moderado”, y “costos = alto”. Sólo uno de los valores de cada atributo es verdadero para un ejemplo concreto, los otros
valores son falsos.

Este operador realiza una normalización. Esto se puede hacer entre un valor mínimo y máximo definido por el usuario o por una transformación z, es decir, media 0 y varianza 1, o por una transformación proporcional
a suma total de los atributos correspondientes.

Devuelve un vector de performance que sólo cuenta la cantidad de atributos utilizados actualmente por el conjunto de ejemplos dado.

CFS evaluador de subconjuntos de atributos. Para obtener más información, consultar: Hall, M. A. (1998). Selección de subconjuntos de características basado en la correlación para Aprendizaje Automático. Tesis
presentada en cumplimiento parcial de los requisitos del grado de Doctor en Filosofía de la Universidad de Waikato.

Este operador crea un filtro basado en la medida de performance para un subconjunto de características. Se evalúa el valor de un subconjunto de atributos, considerando la capacidad individual de predicción de cada
característica junto con el grado de redundancia entre ellos. Se prefieren los subconjuntos de características que están altamente correlacionadas con la clase mientras tienen baja intercorrelación.

Este operador se puede aplicar sobre conjuntos de datos numéricos y nominales.

Este operador evaluador de performance se debe utilizar para las tareas de clasificación, es decir, en los casos donde el atributo label tiene un tipo de valor binominal. Otras tareas de clasificación polinominal, es
decir, tareas con más de dos clases pueden ser manejadas por el operador PolynominalClassificationPerformanceEvaluator. Este operador espera un Conjunto de Ejemplos de prueba como entrada, cuyos elementos tienen tanto las etiquetas verdaderas como las pronosticadas, y entrega como salida una lista de valores de performance que se calculan de acuerdo a una lista de criterios de performance. Si ya se dio un vector de performance de entrada, este se utiliza para mantener los valores de performance.

Todos los criterios de performance se pueden activar utilizando parámetros booleanos. Sus valores pueden ser consultados por un operador ProcessLog usando los mismos nombres. El criterio principal se utiliza
para las comparaciones y debe ser especificado sólo para procesos donde se comparan los vectores de performance, por ejemplo, selección de características u otras configuraciones de procesos de meta
optimización. Si no se selecciona ningún criterio principal, se asumirá que el criterio principal es el primer criterio del vector de performance resultante.

Los vectores de performance resultantes usualmente se comparan con un comparador de performance estándar que sólo compara los valores de aptitud del criterio principal. Se pueden especificar otras  implementaciones de este comparador simple utilizando el parámetro comparator_class. Esto puede ser útil por ejemplo, si se desea comparar vectores de performance de acuerdo a la suma ponderada de los criterios individuales. Para implementar su propio comparador, simplemente subclase de PerformanceComparator. Tener en cuenta que para la optimización multi-objetivos real se suele utilizar otro esquema de selección en lugar de simplemente sustituir el comparador de performance.

Este operador evaluador de performance se debe utilizar para tareas de clasificación, es decir, en los casos donde el atributo etiqueta tiene un tipo de valor (poli-)nominal.

Este operador espera un Conjunto de Ejemplos de prueba como entrada, que contiene un atributo con el rol label (etiqueta) y otro con el rol prediction (predicción). Consultar el operador Set Role para más detalles.
Sobre la base de estos dos atributos se calcula un Vector de Performance, que contiene los valores de los criterios de performance.

Si un Vector de Performance fue alimentado en la entrada performance, sus valores se mantienen si no contienen nuevos criterios. De lo contrario, los valores son promediados con los valores antiguos y los nuevos.

Todos los criterios de performance se pueden activar utilizando parámetros booleanos. Sus valores pueden ser consultados por un operador ProcessLog usando los mismos nombres. El criterio principal se utiliza para las comparaciones y debe ser especificado sólo para procesos donde se comparan los vectores de performance, por ejemplo, selección de atributos u otras configuraciones de procesos de meta optimización.

Si no se selecciona ningún criterio principal, se asumirá que el criterio principal es el primer criterio del vector de performance resultante.

Este operador evaluador de performance se debe utilizar para tareas de regresión, es decir, en los casos donde el atributo label (etiqueta) tiene un tipo de valor numérico. El operador espera un Conjunto de Ejemplos de prueba como entrada, cuyos elementos tienen las etiquetas verdaderas y las pronosticadas, y entrega como salida una lista de valores de performance que se calculan de acuerdo a una lista de criterios de performance. Si ya se dio un vector de performance de entrada, este se utiliza para mantener los valores de performance.

Todos los criterios de performance se pueden activar utilizando parámetros booleanos. Sus valores pueden ser consultados por un operador ProcessLog usando los mismos nombres. El criterio principal se utiliza
para las comparaciones y debe ser especificado sólo para procesos donde se comparan los vectores de performance, por ejemplo, selección de características u otras configuraciones de procesos de meta optimización. Si no se selecciona ningún criterio principal, se asumirá que el criterio principal es el primer criterio del vector de performance resultante.

Los vectores de performance resultantes usualmente se comparan con un comparador de performance estándar que sólo compara los valores de aptitud del criterio principal. Se pueden especificar otras  implementaciones de este comparador simple utilizando el parámetro comparator_class. Esto puede ser útil por ejemplo si se desea comparar vectores de performance de acuerdo a la suma ponderada de los criterios individuales. Para implementar su propio comparador, simplemente subclase de PerformanceComparator. Tener en cuenta que para la optimización multi-objetivos real se suele utilizar otro esquema de selección en lugar de simplemente sustituir el comparador de performance.
 

A diferencia de los otros métodos de evaluación de performance, como por ejemplo Performance (Classification), Performance (Binominal Classification) o Performance (Regression), este operador se puede utilizar para todo tipo de tareas de aprendizaje. Determinará automáticamente el tipo de tarea de aprendizaje y calculará los criterios más comunes para este tipo.

Para realizar cálculos de performance más sofisticados, debe utilizar los operadores anteriormente mencionados. Si ninguno de ellos se adapta a sus necesidades, usted podría escribir su propia medida de performance y calcularla con Performance (User-Based).

Este operador espera un Conjunto de Ejemplos de prueba como entrada, que contenga un atributo con el rol label (etiqueta) y otro con el rol prediction (predicción). Consultar el operador Set Role para más detalles.
Sobre la base de estos dos atributos se calcula un Vector de Performance, que contiene los valores de los criterios de performance. Si un Vector de Performance fue alimentado en la entrada performance, sus
valores se mantienen si no contiene nuevos criterios. De lo contrario, los valores son promediados con los valores antiguos y los nuevos.

Los siguientes criterios se destinan a tareas de clasificación binominal:

• Accuracy.
• Precision.
• Recall.
• AUC (optimista).
• AUC (neutral).
• AUC (pesimista).

Los siguientes criterios se destinan a tareas de clasificación polinominal:

• Accuracy.
• Kappa statistic.

Los siguientes criterios se destinan a tareas de regresión:

• Root Mean Squared Error (Raíz cuadrada del error cuadrático medio).
• Mean Squared Error (Error cuadrático medio).

Asocia un criterio Min-Max (MinMaxCriterion) con cada criterio de performance de tipo Medida de Performance. Este criterio utiliza la aptitud mínima alcanzada en lugar de la aptitud media o la ponderación
arbitraria de ambos. Tener en cuenta que los valores medios permanecen iguales y sólo cambian los valores de aptitud.

Este operador evaluador de performance debe ser utilizado para tareas de regresión, es decir, en los casos donde el atributo label tiene un tipo de valor numérico. El operador espera una Conjunto de Ejemplos de
prueba como entrada, cuyos elementos tienen tanto la etiquetas verdaderas como las pronosticadas, y entrega como salida una lista de valores de performance que se calculan de acuerdo a una lista de criterios
de performance. Si ya se dio un vector de performance de entrada, éste se utiliza para mantener los valores de performance.

Se pueden especificar implementaciones adicionales definidas por el usuario de los Criterios de Performance mediante la lista de parámetros additional_performance_criteria. Cada par clave/valor de esta lista deberá especificar un nombre de clase completamente calificado (como clave), y un parámetro de cadena (como valor) que se pasa al constructor. Por favor, asegúrese de que los archivos de clase se encuentren en la ruta de clases (este es el caso si las implementaciones son suministradas por un complemento) y que implementen un constructor de un argumento tomando un parámetro de cadena. También hay que garantizar que estas clases extiendan las Medidas de Performance puesto que el operador Evaluador de Performance sólo admitirá estos criterios. Tener en cuenta que sólo los tres primeros criterios
definidos por el usuario se pueden utilizar como valores de registro (logging) con los nombres de “user1”, ..., “user3”.

Los vectores de performance resultantes usualmente se comparan con un comparador de performance estándar que sólo compara los valores de aptitud del criterio principal. Se pueden especificar otras implementaciones de este simple comparador utilizando el parámetro comparator_class. Esto puede ser útil por ejemplo si se desea comparar los vectores de performance de acuerdo a la suma ponderada de los criterios individuales. Para implementar su propio comparador, simplemente subclase de PerformanceComparator. Tener en cuenta que para la optimización multi-objetivo real se suele utilizar otro esquema de selección en lugar de simplemente sustituir el comparador de performance.

Determina si la hipótesis nula (todos los valores medios reales son iguales) se cumple para los vectores de performance de entrada. Este operador utiliza un enfoque ANalysis Of VAriances (análisis de varianza)

para determinar la probabilidad de que la hipótesis nula es incorrecta.

Determina si la hipótesis nula (todos los valores medios reales son iguales) se cumple para los vectores de performance de entrada. Este operador utiliza una simple prueba t (en pares) para determinar la probabilidad
de que la hipótesis nula es incorrecta. Dado que una prueba t sólo se puede aplicar a dos vectores de performance esta prueba se aplicará a todos los pares posibles. El resultado es una matriz de significancia.
Sin embargo, la prueba t de a pares puede introducir un error de tipo I mayor. Se recomienda aplicar una prueba de ANOVA adicional para determinar si la hipótesis nula es totalmente incorrecta.

Una Cadena de Validación RandomSplit divide el conjunto de ejemplos en 2 conjuntos, uno de prueba y otro de entrenamiento, y evalúa el modelo. El primer operador interno debe aceptar un Conjunto de Ejemplos, mientras que el segundo debe aceptar un Conjunto de Ejemplos y la salida del primero (que en la mayoría de los casos es un modelo) y debe producir un Vector de Performance.

Este operador de validación proporciona varios valores que se pueden registrar mediante un operador Log de proceso. Todos los operadores de estimación de performance de RapidMiner facilitan el acceso a los valores medios calculados durante la estimación. Debido a que el operador no puede asegurar los nombres de los criterios entregados, el operador Log de proceso puede acceder a los valores a través de nombres genéricos de valores:

• performance: el valor del criterio principal calculado por este operador de validación.
• performance1: el valor del primer criterio del vector de performance calculado.
• performance2: el valor del segundo criterio del vector de performance calculado.
• performance3: el valor del tercer criterio del vector de performance calculado.
• para el criterio principal, también se puede acceder a la varianza y la desviación estándar en su caso.

X-Validation realiza un proceso de validación cruzada. La entrada ExampleSet S se divide en varios subconjuntos de validaciones S_i. Los subprocesos internos se aplican varias veces en validaciones usando S_i como conjunto de prueba (entrada del subproceso Testing) y S \ S_i como conjunto de entrenamiento (entrada del subproceso Training).

El subproceso Training debe devolver un modelo, que suele ser entrenado con la entrada ExampleSet. El subproceso Training debe devolver un Vector de Performance. Este se suele generar aplicando el modelo y
midiendo su performance. Se pueden pasar objetos adicionales desde el subproceso Training al Testing a través de los puertos.

Al igual que los otros esquemas de validación, la validación cruzada de RapidMiner puede utilizar varios tipos de muestreo para construir los subconjuntos. Linear sampling (muestreo lineal) simplemente divide el
conjunto de ejemplos en particiones sin cambiar el orden de los ejemplos. Shuffled sampling (muestreo mezclado) crea subconjuntos aleatorios a partir de los datos. Stratified sampling (muestreo estratificado)
crea subconjuntos aleatorios y asegura que la distribución de clases en los subconjuntos sea igual que en todo el conjunto de ejemplos. Para tener particiones aleatorias independientes del proceso anterior, se podría
utilizar una semilla aleatoria local. Ver los parámetros para más detalles.

El operador de validación cruzada proporciona varios valores que se pueden registrar por medio de un Log. Por supuesto, se puede registrar la cantidad actual de iteraciones, lo que podría ser útil para los operadores
ProcessLog encapsulados en una validación cruzada. Además de esto, todos los operadores de estimación de performance de RapidMiner facilitan el acceso a los valores medios calculados durante la estimación.
Debido a que el operador no puede asegurar los nombres de los criterios entregados, el operador ProcessLog puede acceder a los valores por medio de nombres genéricos de valores:

• performance: el valor del criterio principal calculado por este operador de validación.
• performance1: el valor del primer criterio del vector de performance calculado.
• performance2: el valor del segundo criterio del vector de performance calculado.
• performance3: el valor del tercer criterio del vector de performance calculado.
• para el criterio principal, también se puede acceder a la varianza y la desviación estándar en su caso.

Este operador evalúa la performance de los algoritmos de ponderación y selección de características. El primer subproceso contiene el algoritmo a evaluar. Este debe devolver un vector de pesos de atributos que
luego se aplica sobre los datos de prueba. El mismo pliegue XValidation de los datos se utiliza para crear un nuevo modelo durante el segundo subproceso. Este modelo se evalúa en el tercer subproceso, por lo que
tiene que devolver un vector de performance. Este vector de performance sirve como un indicador de performance para el algoritmo real. Esta implementación de una MethodValidationChain funciona de forma
similar a la XValidation.

Escribe todos los atributos de un conjunto de ejemplos en un archivo. Cada línea contiene la descripción de la construcción de un atributo. Este archivo se puede leer en otro proceso utilizando el Operador de Generación de Características o el Cargador de Construcciones de Atributos.

Escribe los pesos de todos los atributos de un Conjunto de Ejemplos en un archivo. Por lo tanto es necesario un objeto AttributeWeights (Pesos de los Atributos) en la entrada de este operador. Cada línea contiene el
nombre de un atributo y su peso. Este archivo se puede leer en otro proceso utilizando el Cargador de Pesos de Atributos y el Aplicador de Pesos de Atributos.

Escribe un conjunto de parámetros en un archivo. Este se puede crear mediante uno de los operadores de optimización de parámetros, por ejemplo, un operador Optimize Parameters (Grid). Este se puede aplicar
luego a los operadores del proceso utilizando un ParameterSetter.

Carga un conjunto de atributos desde un archivo y construye las características deseadas. Si keep_all es falso, los atributos originales se eliminan antes de crear los nuevos. Esto también significa que una selección de características se lleva a cabo sólo si en el archivo se dio un subconjunto de las características originales.

Lee los pesos de todos los atributos de un conjunto de ejemplos desde un archivo y crea un nuevo objeto IO AttributeWeights. Este objeto se puede utilizar para ampliar los valores de un conjunto de ejemplos con la
ayuda del operador Aplicador de Pesos de Atributos.

Lee un conjunto de parámetros desde un archivo que fue escrito por un Operador de Optimización de Parámetros. Este se puede aplicar luego a los operadores del proceso utilizando un ParameterSetter.

Este operador genera reglas de asociación a partir de conjuntos de elementos frecuentes. En RapidMiner, el proceso de extraer conjuntos de elementos frecuentes se divide en 2 partes: en primer lugar, la generación
de conjuntos de elementos frecuentes y en segundo lugar, la generación de reglas de asociación a partir de esos conjuntos.

Para generar conjuntos de elementos frecuentes, se puede utilizar, por ejemplo, el operador FP-Growth. El resultado será un conjunto de elementos frecuentes que se puede utilizar como entrada para este operador.

Este operador calcula todos los conjuntos de elementos frecuentes de un conjunto de datos mediante la creación de una estructura de datos FPTree sobre la base de datos de transacciones. Esta es una copia muy
comprimida de los datos que en muchos casos cabe en la memoria principal, incluso para grandes bases de datos. Todo el conjunto de elementos frecuentes se deriva de este FPTree. Una ventaja importante de FPGrowth comparado con Apriori es que sólo utiliza 2 escaneos de los datos y por lo tanto frecuentemente es aplicable incluso en grandes conjuntos de datos.

Observe que el conjunto de datos dado sólo puede contener atributos binominales, es decir, atributos nominales con sólo 2 valores diferentes. Sólo tiene que utilizar los operadores de preprocesamiento para transformar el conjunto de datos. Los operadores necesarios son los operadores de discretización para cambiar los tipos de valores de los atributos numéricos a nominales y el operador Nominal2Binominal para
transformar los atributos nominales en binominales / binarios.

Los conjuntos de elementos frecuentes son extraídos de las entradas positivas de la base de datos, es decir, de los valores nominales definidos como positivos en la base de datos. Si se utiliza un archivo de
descripción de atributo (.aml) para el operador ExampleSource este corresponde al segundo valor que se define a través de los atributos de clase o etiquetas de valor interno.

Si sus datos no especifican las entradas positivas correctamente, puede configurarlos utilizando el parámetro positive_value. ¡Esto sólo funciona si todos sus atributos contienen este valor!

Este operador tiene dos modos básicos de trabajo: encontrar al menos la cantidad especificada de conjuntos de elementos con mayor soporte, sin tener en cuenta el min_support (por defecto) o encontrar todos los
conjuntos de elementos con soporte mayor que min_support.

Este operador realiza la ponderación de características con un enfoque de estrategias evolutivas. La varianza de la mutación aditiva gaussiana pueden ser adaptada por una regla 1/5.

Este operador calcula la relevancia de una característica obteniendo para cada atributo del Conjunto de Ejemplos de entrada el valor de la estadística chi-cuadrado con respecto al atributo de clase.

Aprendiz Naive Bayes.

Este operador calcula un modelo de regresión lineal. Utiliza el criterio de Akaike para la selección del modelo.

Una implementación de los k vecinos más cercanos.

Este operador utiliza una matriz de costos dada para obtener las predicciones de label según los costos de clasificación. El método usado por este operador es similar al MetaCost según lo descrito por Pedro 
Domingos.

Esta clase utiliza n +1 aprendices internos y genera n modelos diferentes utilizando los n aprendices anteriores. Las predicciones de estos n modelos se toman para crear n características nuevas para el conjunto de ejemplos, que finalmente se utiliza como entrada del primer aprendiz interno.
 

Este aprendiz utiliza la implementación en Java de la Máquina de Vectores Soporte mySVM por Stefan Rüping. Este método de aprendizaje puede ser utilizado para regresión y clasificación y proporciona un
algoritmo rápido y buenos resultados para muchas tareas de aprendizaje.

Aplica el aprendiz libsvm por Chih-Chung Chang y Chih-Jen Lin. La SVM es un método potente para clasificación y regresión. Este operador soporta los tipos de SVM C-SVC y un nu-SVC para tareas de clasificación, así como epsilon-SVR y nu-SVR para tareas de regresión.

Además one-class brinda la posibilidad de aprender a partir de sólo una clase de ejemplos y luego probar si nuevos ejemplos coinciden con los conocidos. En comparación con los otros aprendices de SVM, el libsvm
también soporta aprendizaje interno multiclase y la estimación de probabilidad basada en la escala de Platt para valores de confianza adecuados después de aplicar el modelo aprendido sobre un conjunto de datos de
clasificación.

Este operador aprende árboles de decisión, tanto de datos nominales como numéricos. Los árboles de decisión son potentes métodos de clasificación, que con frecuencia también se pueden entender fácilmente. Para clasificar un ejemplo, se recorre el árbol desde arriba hacia abajo. Cada nodo de un árbol de decisión se etiqueta con un atributo. El valor del ejemplo para este atributo determina cuál de los arcos resultantes se toma. Para atributos nominales, hay un arco que sale por cada valor posible del atributo, y para atributos numéricos los arcos salientes se etiquetan con intervalos disjuntos.

Este aprendiz de árbol de decisión funciona de forma similar a C4.5 de Quinlan o CART. En términos generales, el algoritmo de árbol de inducción trabaja de la siguiente manera. Cuando se crea un nuevo nodo
en un momento determinado, se elige un atributo para maximizar el poder discriminativo de ese nodo con respecto a los ejemplos asignados al subárbol particular. Este poder discriminativo se mide por un criterio
que puede ser seleccionado por el usuario (obtener información, tasa de ganancia, índice de Gini, etc.)

El algoritmo se detiene en varios casos:

• Ningún atributo alcanza un determinado umbral (minimum_gain).
• Se alcanza la profundidad máxima.
• Hay menos de un cierto número de ejemplos (minimal_size_for_split) en el subárbol actual.

Por último, se poda el árbol, es decir, se quitan las hojas que no aumentan el poder discriminativo de todo el árbol.

Este operador representa una implementación de k-medias. Creará un atributo de cluster si todavía no está presente.

Este operador aplica un modelo a un Conjunto de Ejemplos. Los modelos suelen contener información sobre los datos con los han sido entrenados. Esta información se puede utilizar para predecir el valor de una etiqueta posiblemente desconocida, reproducir algunas transformaciones como durante el entrenamiento o realizar otros cambios. Todos los parámetros necesarios se almacenan dentro del objeto modelo.

Por favor, prestar atención al hecho de que la aplicación de los modelos necesitará los mismos atributos durante la aplicación sobre un Conjunto de Ejemplos que cuando formaron parte del Conjunto de Ejemplos en él fueron entrenados. Algunos cambios menores como la adición de atributos serían posibles, pero podrían causar graves errores de cálculo. Por favor, asegúrese de que la cantidad de atributos, el orden, el tipo y el rol son consistentes durante el entrenamiento y la aplicación.

Si el modelo admite vistas, es posible crear una vista en lugar de cambiar los datos subyacentes. Para indicar al operador Apply Model que la haga, sólo hay que habilitar el parámetro create view. La 
transformación que normalmente sería realizada directamente sobre los datos, en este caso será calculada cada vez que se requiera un valor y el resultado se devuelve sin cambiar los datos. Por favor, tener en cuenta que no todos los modelos soportan vistas.

Si se tiene que aplicar varios modelos en fila, como por ejemplo cuando se tiene que aplicar algunos modelos de preprocesamiento antes de aplicar un modelo de predicción, entonces se podrían agrupar los
modelos. Esto es posible utilizando el operador Group Models de forma conveniente.

Este operador agrupa todos los modelos de entrada para formar un modelo agrupado (combinado). Este modelo se puede aplicar completamente sobre nuevos datos o escrito en un archivo en otro momento. Esto podría ser útil en los casos donde los modelos de preprocesamiento y predicción deben ser aplicados en forma conjunta sobre datos nuevos y no vistos.

Este operador sustituye al agrupamiento automático de modelos conocidos de versiones anteriores de RapidMiner. El uso explícito de este operador de agrupamiento le da al usuario más control sobre el
procedimiento de agrupación. Un modelo agrupado se puede desagrupar con el operador ModelUngrouper.

Tener en cuenta que los modelos de entrada se agregan en orden inverso, es decir, el último modelo creado, que suele ser el primero al inicio del objeto IO, se agregará a la cola como el último modelo del modelo combinado del grupo.

Este operador aplica el umbral dado a un conjunto ejemplos y mapea una predicción soft a valores crisp. Si la confianza para la segunda clase (generalmente positiva para RapidMiner) es mayor que el umbral dado, la predicción se establece a esta clase.

Este operador encuentra el mejor umbral para la clasificación crisp en base a los costos definidos por el usuario.

Este operador desagrupa un modelo previamente agrupado (ModelGrouper) y entrega los modelos agrupados de la entrada.

Este operador sustituye al agrupamiento automático de modelos conocido de versiones anteriores de RapidMiner. El uso explícito de este operador de desagrupamiento le da al usuario más control sobre el
procedimiento de desagrupación. Los modelos simples se pueden agrupar con el operador ModelGrouper.

Este operador se puede utilizar para emplear un solo operador interno o una cadena de operadores. El parámetro select_which permite definir qué operador se debe utilizar. Junto con uno de los operadores de
optimización de parámetros o iteración, este operador se puede utilizar para cambiar dinámicamente la configuración del proceso que pueda ser útil para probar diferentes diseños, por ejemplo, la ganancia
mediante el uso de diferentes pasos de preprocesamiento o cadenas o la calidad de determinado aprendiz.

Este operador toma un conjunto de datos de entrada y le aplica sus operadores internos tantas veces como lo indica el número de características de los datos de entrada. Los operadores internos pueden acceder al
nombre actual de la característica mediante una macro, cuyo nombre se puede especificar a través del parámetro iteration_macro.

El usuario puede especificar con un parámetro si este bucle debe iterar sobre todas las características o sólo sobre las características con un tipo de valor específico, es decir, sólo sobre características numéricas o
sobre características nominales. También se puede especificar una expresión regular que se utiliza como filtro, es decir, los operadores internos sólo se aplican para nombres de características que coinciden con la
expresión de filtro.

En cada paso de iteración, este meta operador ejecuta su proceso interno para el Conjunto de Ejemplos de entrada. Esto sucederá para cada valor posible de atributo de los atributos especificados si all está
seleccionada para el parámetro values. Si se selecciona above p, se realiza una iteración solamente para aquellos valores que presentan una tasa de ocurrencia de por lo menos p. Esto puede ser útil, solamente si se deben considerar grandes subgrupos.

Se puede acceder al valor actual del bucle con el nombre de la macro especificada.

Este operador encuentra los valores óptimos para un conjunto de parámetros mediante una búsqueda en red (grid search). El parámetro parameters es una lista de pares de valores en clave donde las claves tienen la forma nombre_operador.nombre_parámetro y el valor es una lista de valores separados por comas (por ejemplo: 10,15,20,25) o una definición de intervalo en el formato [inicio; fin; amplitud del paso] (por ejemplo [10; 25; 5]). De forma alternativa, se puede utilizar un patrón de valores de red (grid), por ejemplo: [inicio; fin; no_steps; escale], donde escale identifica el tipo del patrón.

El operador devuelve un Conjunto óptimo de Parámetros que también se puede guardar en un archivo con un Grabador de Conjunto de Parámetros. Este conjunto de parámetros se puede leer en otro proceso
utilizando un Cargador de Conjunto de Parámetros.

El formato de archivo del archivo de configuración de parámetros es sencillo y se puede generar fácilmente mediante aplicaciones externas. Cada línea tiene la forma:

• nombre_operator.nombre_parámetro = valor

Además del conjunto de parámetros, devuelve todos los resultados internos generados durante la ejecución que entregó la mejor performance.

Por favor consulte la sección Procesos Avanzados / Análisis de Parámetros y Performance para un ejemplo de aplicación. Otros esquemas de optimización de parámetros como el Operador de Optimización Evolutiva
de Parámetros también pueden ser útiles si no se conocen totalmente los mejores rangos y dependencias. Otro operador que funciona de forma similar a este operador de optimización parámetros es el operador de Iteración de Parámetros. A diferencia del operador de optimización, este operador simplemente recorre todas las combinaciones de parámetros. Esto podría ser especialmente útil para los fines de graficación.

Esto operador copia su objeto de entrada a todos los puertos de salida conectados. Mientras más puertos están conectados, más copias se generan. Tener en cuenta que los objetos se copian por referencia, por lo
tanto, los datos subyacentes de los Conjuntos de Ejemplos nunca se copian (a menos que utilice un operador Materialize Data). Por lo tanto, la copia de objetos no es costosa. Al copiar los Conjuntos de Ejemplos sólo se copian las referencias a los atributos. Cuando se modifican o agregan atributos a un Conjunto de Ejemplos, este cambio es invisible para las otras copias. Sin embargo, si se modifican los datos en un hilo
del flujo del proceso, también se modifica en las otras copias.

Establece un conjunto de parámetros. Estos parámetros se pueden generar por un Operador de Optimización de Parámetros o leer mediante un Cargador de Conjunto de Parámetros. Este operador es útil, por ejemplo, en la siguiente situación. Si se desea encontrar los mejores parámetros para un determinado esquema de aprendizaje, por lo general también interesa el modelo generado con estos parámetros. Mientras los primeros se pueden obtener fácilmente utilizando un Operador de Optimización de Parámetros, el último no es posible porque el Operador de Optimización de Parámetros no devuelve los Objetos IO generados en su interior, sino solamente un conjunto de parámetros. Esto se debe a que el operador de optimización de parámetros no sabe nada acerca de los modelos, sino sólo sobre los vectores de performance producidos en su interior. Los vectores de performance no necesariamente requieren un modelo. Para resolver este problema, se puede utilizar un ParameterSetter. Por lo general, un proceso con un ParameterSetter contiene por lo menos dos operadores del mismo tipo, usualmente un aprendiz. Un aprendiz puede ser un operador interno del Operador de Optimización de Parámetros y se puede denominar “Aprendiz”, mientras que un segundo aprendiz del mismo tipo denominado “AprendizOptimo” sigue la optimización de parámetros y debe utilizar el conjunto óptimo de parámetros encontrados por la optimización.

Para hacer que el ParameterSetter establezca los parámetros óptimos del operador correcto, hay que especificar su nombre. Cada parámetro de la lista de parámetros name_map mapea el nombre de un operador que se utilizó durante la optimización (en este caso es el "Aprendiz") a un operador que ahora debe utilizar estos parámetros (en este caso es el “AprendizOptimo”).

Este operador se puede utilizar para acceder a los repositorios presentados en RapidMiner 5. Este debería sustituir a todos los accesos a archivos, porque proporciona todo el procesamiento de los metadatos, lo que facilita mucho el uso de RapidMiner. A diferencia del acceso a un archivo sin procesar, éste operador proporcionará todos los metadatos de los datos, de modo que posibilita todas las transformaciones de los metadatos.

El único parámetro repository_entry referencia una entrada del repositorio que se devolverá como salida de este operador. Las ubicaciones de los repositorios se resuelven en relación a la carpeta del repositorio que contiene al proceso actual. Las carpetas del repositorio están separadas mediante una barra inclinada (/), “..” hace referencia a la carpeta padre. Una barra inclinada inicial hace referencia a la carpeta raíz del repositorio que contiene al proceso actual. Una doble barra inclinada inicial se interpreta como una ruta absoluta que comienza con el nombre de un repositorio.

• “MisDatos” busca una entrada “MisDatos” en la misma carpeta que contiene el proceso actual.
• “.. /entrada/MisDatos” busca una entrada “MisDatos”, ubicada en la carpeta “entrada” próxima a la carpeta que contiene el proceso actual.
• “/datos/Modelo” busca una entrada “Modelo” en la carpeta “datos” de nivel superior en el repositorio que contiene al proceso actual.

Este operador almacena Objectos IO en un lugar de un repositorio. 

Este operador agrega atributos aleatorios y ruido blanco a los datos. Nuevos atributos aleatorios son simplemente completados con datos aleatorios que no están correlacionados en absoluto con el label (la etiqueta). Además, este operador puede agregar ruido al atributo label o a los atributos regulares. En el caso de un label numérico, el label_noise dado es el porcentaje del rango del label el que define la desviación estándar del ruido normalmente distribuido que se agrega al atributo label. Para las etiquetas nominales el parámetro label_noise define la probabilidad de cambiar aleatoriamente el valor de la etiqueta nominal. En el caso de agregar ruido a los atributos regulares. El parámetro default_attribute_noise simplemente define la desviación estándar del ruido normalmente distribuido sin utilizar el rango de valores de atributo. Usando la lista de parámetros es posible establecer diferentes niveles de ruido para diferentes atributos. Sin embargo, esto no es posible al agregar ruido a los atributos nominales.
 

Genera un conjunto aleatorio de ejemplos para propósitos de prueba. Utiliza una subclase de TargetFunction (Función Objetivo) para crear los ejemplos a partir de los valores de los atributos. Las funciones objetivo posibles son: random, sum (de todos los atributos), polynomial (de los 3 primeros atributos, grado 3), non linear, sinus, sinus frequency (como sinus, pero con frecuencias en el argumento), random classification, sum classification (como sum, pero positivo para sum positivo y negativo para sum negativo), interaction classification (positivo par x negativo o positivo y y negativo z), sinus classification (positivo para los valores positivos del seno).

Este operador registra datos casi arbitrarios. Estos se pueden guardar en un archivo que luego se puede leer, por ejemplo por gnuplot. Por otra parte, los datos recogidos se pueden graficar mediante la GUI. Esto es posible incluso en tiempo de ejecución del proceso (es decir, graficación en línea). 

Los parámetros de la lista log se interpretan de la siguiente manera: El parámetro key da el mismo nombre para el nombre de columna (por ejemplo, para su uso en el graficador). El parámetro value especifica de
dónde recuperar el valor. Esto se explica mejor con un ejemplo:

• Si el valor es operator.Evaluador.value.absolute, el operador ProcessLog busca el operador con el nombre Evaluador. Si este operador es un Evaluador de Performance, tiene un valor denominado absolute que da el error absoluto de la última evaluación. Este valor se consulta mediante el operador ProcessLog.
• Si el valor es operator.AprendizSVM.parameter.C, el operador ProcessLog busca el parámetro C del operador denominado AprendizSVM.

Cada vez que se aplica el operador ProcessLog, todos los valores y parámetros especificados por la lista log se recogen y se almacenan en una fila de datos. Al finalizar el proceso, el operador escribe las filas de datos recopiladas en un archivo (si se especifica). En el modo de GUI, 2D o 3D, se generan automáticamente los gráficos y se muestran en el visor de resultados. Por favor consultar la sección Procesos Avanzados / Análisis de Parámetros y Performance para un ejemplo de aplicación.

Este operador (re-)define una macro para el proceso actual. Las macros serán sustituidas en las cadenas de valores de los parámetros por los valores de las macros, ver más abajo la sección Macros. A diferencia del
habitual operador Set Macro, este operador establece el valor de una sola macro a partir de las propiedades de un Conjunto de Ejemplos de entrada dado, por ejemplo, a partir de propiedades como la cantidad de
ejemplos o atributos, o de un valor específico de dato. El nombre de la macro se debe especificar en el parámetro macro y la forma de recuperar el valor desde el Conjunto de Ejemplos, se debe seleccionar de
macro_type.

Macros

Una macro definida se puede utilizar luego en todos los operadores sucesivos como valor de parámetro para los parámetros. Una macro entonces debe estar encerrada entre “%(” y “)”.

Hay varias macros predefinidas:

• %{process_name}: se sustituye por el nombre del proceso (sin ruta de acceso y extensión) .
• %{process_file}: se sustituye por el nombre de archivo del proceso (con extensión).
• %{process_path}: se sustituye por la ruta absoluta completa del archivo del proceso.

Además de éstas el usuario puede definir arbitrariamente otras macros que serán sustituídas por cadenasn arbitrarias durante la ejecución del proceso. Tener en cuenta que también existen algunas macros cortas, por ejemplo, %{a} para el número de veces que se aplicó el operador actual.

Tener en cuenta además que otros operadores como muchos de los operadores de bucle como Loop Values o Loop Attributes también agregan macros específicas.

(Re)define macros para el proceso actual. Las macros serán sustituídas en las cadenas de valor de los parámetros por los valores de la macro definida como parámetro de este operador. A diferencia del habitual
Operador de Definición de Macros, este operador sólo soporta la definición de una sola macro, por lo que se puede utilizar dentro de iteraciones de parámetro.

Hay que definir el nombre de la macro (sin encerrar entre corchetes) y el valor de la macro. La macro definida luego se puede utilizar en todos los operadores sucesivos como valor del parámetro. Una macro
debe entonces estar encerrada por “MACRO_START” y “MACRO_END”.

Hay varias macros predefinidas:

• MACRO_STARTnombre_procesoMACRO_END: se sustituye por el nombre del proceso (sin ruta de acceso y extensión).
• MACRO_STARTarchivo_procesoMACRO_END: se sustituye por el nombre de archivo del proceso (con extensión).
• MACRO_STARTruta_procesoMACRO_END: se sustituye por la ruta absoluta completa del archivo del proceso.

Además de éstas el usuario puede definir arbitrariamente otras macros que serán sustituídas por cadenas arbitrarias durante la ejecución del proceso. Tener en cuenta que también existen algunas macros cortas, por
ejemplo, MACRO_STARTaMACRO_END para el número de veces que se aplicó el operador actual. Por favor, consultar la sección sobre macros en el tutorial de RapidMiner. Tener en cuenta además que otros
operadores como el FeatureIterator también agregan macros específicas.

Limpia los recursos de memoria no utilizados. Podría ser muy útil en combinación con el operador MaterializeDataInMemory después de grandes árboles de preprocesamiento utilizando gran cantidad de vistas o copias de los datos. Internamente, este operador simplemente invoca la recolección de basura del lenguaje de programación Java subyacente.

Crea una copia reciente y limpia de los datos en la memoria. Podría ser muy útil en combinación con el operador MemoryCleanUp después de grandes árboles de preprocesamiento utilizando gran cantidad de vistas o copias de los datos.

Una cadena de un solo operador que puede tener una cantidad arbitraria de operadores internos. Los operadores son posteriormente aplicados y sus salidas se utilizan como entrada para el operador subsiguiente. La entrada de la cadena de operador se utiliza como entrada para el primer operador interno y la salida del último operador se utiliza como salida de la cadena de operador.