Motor de decisión Multi-IA para MQL5 (Parte 4): ¿El multi-IA le gana a una sola IA? Diario, scorecard y costo
35
0
Introducción
En las tres partes anteriores construimos un motor que consulta a varias IA y combina sus respuestas: la Parte 1 armó la arquitectura y el voto, la Parte 2 le enseñó a confiar más en la IA que más acierta y le puso gestión de riesgo, y la Parte 3 le dio el contexto correcto (régimen y noticias). En todo ese camino hubo un supuesto que nunca puse a prueba y que es, en el fondo, la razón de ser de todo el proyecto: que consultar a cuatro IA y votar es mejor que seguir a una sola.
Suena razonable, pero "suena razonable" no es un dato. Quizá una de las cuatro acierta tanto que el voto la frena en vez de ayudar. Quizá las cuatro se equivocan a la vez justo cuando importa. Quizá el combinado empata con la mejor IA individual y estás pagando cuatro APIs para nada. No hay forma de saberlo sin medirlo. Hasta ahora el motor decidía sin dejar rastro: tomaba una decisión, abría o no una operación y luego la descartaba.
Esta parte agrega la capa que faltaba: la evaluación. Cada decisión queda anotada en un diario. Cada IA recibe una nota como si la hubiéramos seguido sola, y el voto combinado recibe la suya. Luego comparamos esos resultados con el costo real (en USD) de consultar a las cuatro. El resultado es un scorecard que contesta la pregunta honesta: ¿el multi-IA aporta, o no?
Este es un marco educativo y de diagnóstico, no un sistema rentable. La salida de la IA es orientación, no es consejo financiero. Pruébalo en una cuenta demo.
Por qué medir en vez de asumir
El error clásico al armar un conjunto de modelos (un "ensemble") es enamorarse de la idea y no chequear si funciona. La intuición dice que juntar varias opiniones promedia los errores, pero eso solo es cierto si los errores son independientes. Si las cuatro IA leen el mismo precio y el mismo contexto, muchas veces se equivocan juntas, y entonces el voto no te salva de nada: te da la misma respuesta equivocada con más confianza.
Un ejemplo simple aclara por qué la comparación importa. Supongamos que, sobre cien decisiones, OpenAI acierta el 55%, Claude el 52%, Gemini el 48% y DeepSeek el 50%. El voto combinado podría dar 57%: mejor que la mejor individual, y ahí el conjunto se justifica. Pero también podría dar 53%, peor que OpenAI sola, porque las dos IA flojas arrastran el promedio hacia abajo; en ese caso conviene seguir solo a OpenAI o quitar las restantes. Los dos escenarios se ven idénticos hasta que los mides, y el scorecard es justamente lo que los separa.
La única manera de saber si el combinado aporta es compararlo contra cada IA por separado, bajo las mismas condiciones. Y "las mismas condiciones" tiene que ser justo: misma señal, mismo horizonte para juzgarla y mismo umbral de movimiento. Si evalúo a una IA en un momento y al voto en otro, la comparación no vale. Por eso reutilizo exactamente el mismo criterio que ya usa la Parte 2 para calificar una predicción (un movimiento de al menos InpEvalThresholdPts puntos a favor dentro de InpEvalSeconds segundos), pero ahora lo aplico a todos los votantes a la vez y también al voto combinado.
Hay una distinción importante con la Parte 2. Allí el motor ya lleva un hit-rate interno (un promedio que decae) para ponderar el voto: es una señal de trabajo, viva, que cambia rápido. Lo de esta parte es otra cosa: un registro acumulativo y honesto de cada decisión, pensado para el reporte y la comparación, no para ponderar. Una cosa alimenta el motor; la otra te deja auditarlo.
El ciclo es simple: cuando el motor consulta a las IA y vota, guardamos una foto del momento (qué dijo cada una y qué decidió el conjunto). Cuando pasa el horizonte, miramos cuánto se movió el precio y calificamos esa foto: cada IA por separado y el combinado. Esa nota se acumula en un scorecard y se escribe en un CSV que puedes abrir después en una planilla.
Los parámetros y el estado nuevos
Sobre los inputs de las partes anteriores agregamos un grupo de evaluación y costo. Lo único configurable aquí es si mostramos el panel y cuánto cuesta, en dólares, una llamada a cada proveedor (edita esos valores según el precio de tu plan).
//--- evaluation & cost (Part 4) input bool InpShowDashboard = true; // Show the live scorecard panel on the chart input double InpCostOpenAI = 0.00020; // Est. USD per OpenAI call (edit to your pricing) input double InpCostClaude = 0.00120; // Est. USD per Claude call input double InpCostGemini = 0.00010; // Est. USD per Gemini call input double InpCostDeepSeek = 0.00015; // Est. USD per DeepSeek call
El estado nuevo son dos estructuras. La primera, Scorecard, es un par de contadores: cuántas decisiones direccionales se tomaron y cuántas salieron bien. La segunda, JournalEntry, es la foto completa de un ciclo: la hora, el precio de entrada, cuándo vence, la señal y la confianza de cada una de las cuatro IA, y la decisión combinada.
//--- NEW (Part 4) - cumulative wins/trades for a provider or for the engine struct Scorecard { int trades; // directional calls taken (HOLD never counts) int wins; // how many were right at the horizon }; //--- NEW (Part 4) - a full snapshot of one evaluation cycle, graded later struct JournalEntry { datetime time; double entryPrice; datetime dueTime; ENUM_AI_SIGNAL provSignal[4]; // each provider's signal at decision time double provConf[4]; bool provValid[4]; ENUM_AI_SIGNAL multiSignal; // the combined vote bool active; };
Y unas pocas variables globales: un scorecard por proveedor (como si hubiéramos seguido solo a esa IA), un scorecard para el combinado, el array de fotos pendientes de calificar, y dos acumuladores de costo.
//--- Part 4 state Scorecard g_scoreProv[4]; // per-provider, as if we had followed ONLY that AI Scorecard g_scoreMulti; // the combined multi-AI decision JournalEntry g_journal[]; // snapshots waiting to be graded double g_costTotal = 0.0; // cumulative USD spent on API calls int g_roundCount = 0; // query rounds (for cost per round)
Anotar cada decisión: el diario
Cada vez que el motor consulta a las IA, guardamos una foto. Es clave hacerlo en todos los ciclos en los que consultamos, no solo cuando se abre una operación: si una IA dijo COMPRA pero el voto terminó en HOLD, ese desacuerdo es justo lo que queremos medir después. Por eso RecordJournal recibe los votos crudos y la señal combinada, y los archiva juntos.
//+------------------------------------------------------------------+ //| NEW (Part 4) - snapshot every queried cycle for later grading | //+------------------------------------------------------------------+ void RecordJournal(const AIResponse &votes[], ENUM_AI_SIGNAL multiSignal) { int n = ArraySize(g_journal); ArrayResize(g_journal, n + 1); g_journal[n].time = TimeCurrent(); g_journal[n].entryPrice = SymbolInfoDouble(_Symbol, SYMBOL_BID); g_journal[n].dueTime = TimeCurrent() + InpEvalSeconds; g_journal[n].multiSignal = multiSignal; g_journal[n].active = true; for(int i = 0; i < 4; i++) { g_journal[n].provValid[i] = false; g_journal[n].provSignal[i] = AI_SIGNAL_HOLD; g_journal[n].provConf[i] = 0.0; } for(int i = 0; i < ArraySize(votes); i++) { int idx = (int)votes[i].provider; if(idx < 0 || idx > 3) continue; g_journal[n].provValid[idx] = votes[i].valid; g_journal[n].provSignal[idx] = votes[i].signal; g_journal[n].provConf[idx] = votes[i].confidence; } }
Indexamos por proveedor ((int)votes[i].provider) en vez de por la posición en el array, para que la foto sea consistente aunque alguna IA no conteste. Una IA que falla queda con provValid = false y no contará ni como acierto ni como error: no opinó, así que no la juzgamos.
Calificar las decisiones: el contrafáctico multi-vs-single
Aquí está el corazón de la parte. Cuando una foto vence (pasó el horizonte), miramos cuánto se movió el precio desde la entrada y repartimos notas. La regla de qué cuenta como acierto la encapsula una función pequeña, que además deja claro que un HOLD nunca es ni acierto ni error, porque no es una operación.
//+------------------------------------------------------------------+ //| NEW (Part 4) - true if a directional call matched the move | //+------------------------------------------------------------------+ bool SignalCorrect(ENUM_AI_SIGNAL sig, double move, double thr) { if(sig == AI_SIGNAL_BUY) return(move >= thr); if(sig == AI_SIGNAL_SELL) return(move <= -thr); return(false); // HOLD is not a trade: never a win, never a loss }
Con eso, ResolveJournal recorre las fotos vencidas y, para cada una, hace el contrafáctico: califica a cada IA como si hubieras seguido solo a esa IA, y por separado califica la decisión combinada. Los dos usan el mismo movimiento y el mismo umbral, así que la comparación es limpia. Cada foto calificada se escribe en el CSV y se marca como hecha.
//+------------------------------------------------------------------+ //| NEW (Part 4) - grade matured snapshots: scorecard + CSV journal | //+------------------------------------------------------------------+ void ResolveJournal() { double price = SymbolInfoDouble(_Symbol, SYMBOL_BID); double thr = InpEvalThresholdPts * _Point; bool changed = false; for(int i = 0; i < ArraySize(g_journal); i++) { if(!g_journal[i].active || TimeCurrent() < g_journal[i].dueTime) continue; double move = price - g_journal[i].entryPrice; //--- counterfactual: grade each AI as if we had followed only it bool provOk[4], provTraded[4]; for(int p = 0; p < 4; p++) { provOk[p] = false; provTraded[p] = (g_journal[i].provValid[p] && g_journal[i].provSignal[p] != AI_SIGNAL_HOLD); if(!provTraded[p]) continue; g_scoreProv[p].trades++; provOk[p] = SignalCorrect(g_journal[i].provSignal[p], move, thr); if(provOk[p]) g_scoreProv[p].wins++; } //--- grade the combined multi-AI decision the same way bool multiOk = false; if(g_journal[i].multiSignal != AI_SIGNAL_HOLD) { g_scoreMulti.trades++; multiOk = SignalCorrect(g_journal[i].multiSignal, move, thr); if(multiOk) g_scoreMulti.wins++; } WriteJournalRow(g_journal[i], provOk, provTraded, multiOk, move / _Point); g_journal[i].active = false; changed = true; } if(changed) CompactJournal(); }
CompactJournal solo descarta las fotos ya calificadas y conserva las pendientes; es idéntico en idea al CompactPending de la Parte 2, así que no lo repito aquí. Lo que importa es lo que queda en los contadores: para cada IA, en cuántas decisiones direccionales habría entrado y cuántas habría acertado siguiéndola sola; y lo mismo para el voto combinado. Esos dos números, lado a lado, son la respuesta a la pregunta de toda la serie.
Detalle de diseño: calificamos la señal combinada tal como sale del voto, antes de aplicar los filtros de la Parte 3 (noticias y riesgo). Es a propósito. Esos filtros deciden si conviene operar, no qué dirección tiene razón, y las IA individuales tampoco pasan por ellos; comparar el voto crudo contra los votos crudos es lo que mantiene la cancha pareja. Medir cuánto aportan los gates es otro experimento, y el CSV te deja hacerlo después cruzando las columnas a mano.
El costo de consultar varias IA
Comparar aciertos no alcanza: el multi-IA cuesta más, porque son cuatro llamadas en lugar de una. Si el combinado acierta apenas un poco más que la mejor IA individual pero cuesta cuatro veces, quizá no valga la pena. Por eso sumamos el costo de cada ronda. Cobramos solo por las IA que efectivamente contestaron, con el precio que pusiste en los inputs.
//+------------------------------------------------------------------+ //| NEW (Part 4) - estimated USD cost of one round (answered AIs) | //+------------------------------------------------------------------+ double RoundCost(const AIResponse &votes[]) { double cost = 0.0; for(int i = 0; i < ArraySize(votes); i++) { if(!votes[i].valid) continue; switch(votes[i].provider) { case AI_OPENAI: cost += InpCostOpenAI; break; case AI_CLAUDE: cost += InpCostClaude; break; case AI_GEMINI: cost += InpCostGemini; break; case AI_DEEPSEEK: cost += InpCostDeepSeek; break; } } return(cost); }
El número que sale de aquí no pretende ser exacto al centavo; depende de cuántos tokens use tu prompt y del precio del momento. Pero te da una magnitud, y eso es lo que importa para decidir: si el panel te dice que gastaste unos centavos para ganar dos puntos de acierto sobre la mejor IA sola, sabes si el combinado se paga o no.
El reporte: CSV y un panel en el gráfico
El diario vive en dos lugares. El permanente es un CSV en la carpeta MQL5\Files, una fila por decisión calificada, que abres en Excel para analizar con calma. Lo escribimos en modo "agregar", con encabezado solo la primera vez.
//+------------------------------------------------------------------+ //| NEW (Part 4) - append one graded snapshot to the CSV journal | //+------------------------------------------------------------------+ void WriteJournalRow(const JournalEntry &e, const bool &provOk[], const bool &provTraded[], bool multiOk, double movePts) { bool isNew = !FileIsExist("multiai_journal.csv"); int h = FileOpen("multiai_journal.csv", FILE_READ | FILE_WRITE | FILE_CSV | FILE_ANSI, ','); if(h == INVALID_HANDLE) return; FileSeek(h, 0, SEEK_END); if(isNew) FileWrite(h, "time", "symbol", "openai_sig", "openai_ok", "claude_sig", "claude_ok", "gemini_sig", "gemini_ok", "deepseek_sig", "deepseek_ok", "multi_sig", "multi_ok", "move_pts"); FileWrite(h, TimeToString(e.time, TIME_DATE | TIME_MINUTES), _Symbol, SignalToStr(e.provSignal[0]), (provTraded[0] ? (provOk[0] ? "1" : "0") : "-"), SignalToStr(e.provSignal[1]), (provTraded[1] ? (provOk[1] ? "1" : "0") : "-"), SignalToStr(e.provSignal[2]), (provTraded[2] ? (provOk[2] ? "1" : "0") : "-"), SignalToStr(e.provSignal[3]), (provTraded[3] ? (provOk[3] ? "1" : "0") : "-"), SignalToStr(e.multiSignal), (e.multiSignal != AI_SIGNAL_HOLD ? (multiOk ? "1" : "0") : "-"), DoubleToString(movePts, 0)); FileClose(h); }
Cada fila guarda, por proveedor, su señal y un marcador: 1 si acertó, 0 si erró, - si no operó (HOLD o no contestó). Una fila se ve así:
time,symbol,openai_sig,openai_ok,claude_sig,claude_ok,gemini_sig,gemini_ok,deepseek_sig,deepseek_ok,multi_sig,multi_ok,move_pts 2026.06.19 14:00,XAUUSD,BUY,1,BUY,1,HOLD,-,SELL,0,BUY,1,180
El otro lugar es el gráfico, en vivo. ShowDashboard arma un panel de texto con Comment que muestra, por proveedor y para el combinado, cuántas decisiones, cuántos aciertos y el porcentaje, más el costo total acumulado.
//+------------------------------------------------------------------+ //| NEW (Part 4) - draw the live scorecard panel on the chart | //+------------------------------------------------------------------+ void ShowDashboard() { if(!InpShowDashboard) return; string names[4] = {"OpenAI ", "Claude ", "Gemini ", "DeepSeek"}; string txt = "=== Multi-AI Decision Engine - Part 4: Evaluation ===\n"; txt += "Provider Trades Wins WinRate\n"; for(int p = 0; p < 4; p++) { double wr = (g_scoreProv[p].trades > 0) ? 100.0 * g_scoreProv[p].wins / g_scoreProv[p].trades : 0.0; txt += StringFormat("%s %4d %4d %5.1f%%\n", names[p], g_scoreProv[p].trades, g_scoreProv[p].wins, wr); } double wrMulti = (g_scoreMulti.trades > 0) ? 100.0 * g_scoreMulti.wins / g_scoreMulti.trades : 0.0; txt += "----------------------------------------\n"; txt += StringFormat("Multi-AI %4d %4d %5.1f%% <= combined\n", g_scoreMulti.trades, g_scoreMulti.wins, wrMulti); double perRound = (g_roundCount > 0) ? g_costTotal / g_roundCount : 0.0; txt += StringFormat("API cost: $%.4f over %d rounds ($%.5f/round)", g_costTotal, g_roundCount, perRound); Comment(txt); }
El scorecard del panel es de la sesión actual (se reinicia al recargar el EA); el CSV es la memoria permanente. Esa división es a propósito: el panel te da una lectura rápida mientras miras el gráfico, y el CSV junta todo el historial para el análisis serio.
Juntando todo en el EA
Las piezas nuevas se integran en OnTimer sin tocar la lógica de decisión que ya teníamos. Al inicio del ciclo calificamos lo que ya venció (las predicciones de la Parte 2 y el diario de esta parte) y refrescamos el panel. Después, si no hay posición ni noticias cerca, consultamos a las IA, sumamos el costo de la ronda, votamos, y archivamos la foto del ciclo antes del posible HOLD, para no perder los desacuerdos. El gating y la operación quedan igual que en la Parte 3.
//+------------------------------------------------------------------+ //| Timer function | //+------------------------------------------------------------------+ void OnTimer() { //--- 1) grade the Part 2 learning and the Part 4 journal, refresh the panel ResolvePredictions(); ResolveJournal(); ShowDashboard(); if(PositionSelect(_Symbol)) return; //--- 2) news gating in code: don't even ask the AIs during/near a window int minsToStart; int ns = NewsState(minsToStart); if(InpBlockOnNews && ns > 0) { PrintFormat("Skip: scheduled news window %s.", (ns == 2 ? "active" : "imminent (" + (string)minsToStart + " min)")); return; } //--- 3) ask every AI, remember each call, and add up the round's cost AIResponse votes[]; CollectVotes(_Symbol, votes); RecordPredictions(votes); g_costTotal += RoundCost(votes); g_roundCount++; //--- 4) weighted decision (confidence x learned accuracy) AIResponse decision = VoteDecisionWeighted(votes, InpQuorum, InpMinScore); //--- 5) journal the whole cycle (each AI's vote + the combined one), even on HOLD RecordJournal(votes, decision.signal); if(!decision.valid || decision.signal == AI_SIGNAL_HOLD) return; //--- 6) news gating by the AIs: skip if the majority judged the context risky if(InpBlockOnAiRisk && AiRiskMajority(votes)) { Print("Skip: AI majority flagged RISK=HIGH (regime/news)."); return; } //--- 7) risk management: enforced SL/TP and confidence-based lot double price = (decision.signal == AI_SIGNAL_BUY) ? SymbolInfoDouble(_Symbol, SYMBOL_ASK) : SymbolInfoDouble(_Symbol, SYMBOL_BID); double sl, tp; if(!ComputeSLTP(decision.signal, price, sl, tp)) return; double lot = LotByConfidence(decision.confidence, MathAbs(price - sl)); if(decision.signal == AI_SIGNAL_BUY) trade.Buy(lot, _Symbol, 0, sl, tp, "MultiAI P4"); else trade.Sell(lot, _Symbol, 0, sl, tp, "MultiAI P4"); PrintFormat("Decision %s | conf %.1f | lot %.2f | %s | hitrate O%.2f C%.2f G%.2f D%.2f", SignalToStr(decision.signal), decision.confidence, lot, RegimeContext(), g_hitRate[0], g_hitRate[1], g_hitRate[2], g_hitRate[3]); }
Fíjate en el orden: la calificación va primero (es barato y mantiene el scorecard al día aunque haya una posición abierta), y el RecordJournal se llama antes del return por HOLD, así una foto con desacuerdos no se pierde solo porque el voto no operó.
Un ejemplo: leyendo el scorecard
Pongámosle números. Después de un rato corriendo en XAUUSD, el panel podría verse así:
¿Cómo se lee? Cada fila de proveedor dice cuántas veces esa IA, sola, habría operado y con qué acierto. La última fila es el voto combinado. Lo interesante no es el número absoluto sino la comparación: si el Multi-AI supera a la mejor IA individual, el conjunto está aportando; si empata o queda por debajo, no.
En el ejemplo, el combinado opera menos veces que cada IA por separado (porque cuando no hay acuerdo, el voto se abstiene) pero con mejor acierto: filtra las veces en que una sola IA se entusiasma y las demás no la acompañan. Ese es exactamente el efecto que esperábamos del voto, y ahora lo vemos medido en vez de suponerlo. Pero podría pasar lo contrario, y el mismo panel te lo diría sin piedad: si DeepSeek sola acierta más que el combinado, sabes que el voto te está costando aciertos, y tienes que mirar por qué.
Abajo de todo está el costo: unos centavos por ronda. Con eso puedes cerrar el razonamiento: cuántos puntos de acierto te dio el combinado por encima de la mejor IA individual, y si ese margen justifica pagar las cuatro APIs en vez de una.
Un detalle al leer la tabla: no te quedes solo con el porcentaje, mira también la columna de decisiones. Un 70% sobre diez operaciones dice mucho menos que un 58% sobre doscientas; el primero se da vuelta con un par de resultados, el segundo ya es una tendencia. Por eso el panel muestra los dos números juntos, aciertos y total, y no el porcentaje pelado.
Usar esto para podar y afinar
El scorecard no es solo para mirar: es para decidir. Si una IA arrastra el promedio sesión tras sesión, tienes dos caminos. Uno, bajarle el peso: el motor de la Parte 2 ya pondera por acierto, así que una IA mala pierde influencia sola, pero puedes acelerarlo subiendo InpHitRateAlpha. Dos, sacarla del todo si su acierto está consistentemente por debajo del azar y encima es la más cara, porque ahí estás pagando por ruido.
Hay una trampa que conviene evitar: podar demasiado rápido. Si sacas a una IA después de diez decisiones flojas, puedes estar reaccionando a la mala racha de un modelo que en realidad aporta; por eso el peso gradual de la Parte 2 suele ser más prudente que la tijera. Deja la poda dura para cuando el CSV ya juntó muchas filas y el patrón se repite sesión tras sesión.
También sirve para calibrar el horizonte. Si ninguna IA pasa del 50% con tu InpEvalThresholdPts y tu InpEvalSeconds actuales, quizá les estás pidiendo precisión de corto plazo que no pueden dar; prueba un horizonte más largo o un umbral más grande y mira si los aciertos se separan. El diario convierte ese tipo de ajuste en algo que mides, no que adivinas.
Cómo usarlo- Completa keys.txt y autoriza las cuatro URLs de las API en WebRequest, como en las partes anteriores.
- Adjunta el EA a un gráfico. Revisa los inputs nuevos: deja InpShowDashboard en true para ver el panel, y ajusta los cuatro InpCost... al precio real de tu plan en cada proveedor (si no te importa el costo, déjalos en 0).
- Deja correr el motor. El scorecard del gráfico se llena a medida que las decisiones vencen (según InpEvalSeconds); en paralelo se va escribiendo multiai_journal.csv en la carpeta MQL5\Files.
- Cuando tengas suficientes filas, abre el CSV en una planilla y saca tus propias cuentas: acierto por proveedor, acierto del combinado, y el costo. Esa tabla es la que te dice si el multi-IA aporta en tu símbolo y tu horario.
En el gráfico se ve el panel del scorecard (que mostramos más arriba): una fila por IA con sus decisiones, aciertos y porcentaje, la fila del combinado abajo y el costo acumulado. En paralelo, el archivo multiai_journal.csv de la carpeta MQL5\Files se llena con una fila por decisión calificada, lista para abrir en Excel y sacar las cuentas finas. Es la combinación de los dos —la lectura rápida en el gráfico y el registro completo en el CSV— lo que te deja responder, con datos, si el multi-IA aporta en tu símbolo.
Limitaciones
- El veredicto vale lo que valga la muestra. Con pocas decisiones, las diferencias entre IA son ruido; hacen falta muchas filas antes de creer que una le gana a otra.
- El contrafáctico es una aproximación: mide la dirección a un horizonte fijo, no tu salida real con SL/TP ni el slippage. Sirve para comparar IA entre sí en igualdad de condiciones, no para estimar la ganancia exacta.
- Si los modelos están muy correlacionados (leen lo mismo y opinan parecido), el voto aporta poco por diseño, y el scorecard te lo va a mostrar como un combinado que apenas se despega de las individuales.
- El scorecard del panel es de la sesión; la memoria real es el CSV. Y el costo es una estimación: edita los inputs con el precio de tu plan para que sea creíble.
- Marco educativo y de diagnóstico, no consejo financiero.
Conclusión
Cerramos el círculo que abrimos en la Parte 1. Construimos un motor que consulta a varias IA, aprende en cuál confiar, opera con riesgo controlado y razona el contexto; y ahora, por fin, lo medimos en lugar de asumirlo.
El diario, el scorecard y el coste por ronda convierten esa evaluación en algo práctico: ya no solo puedes observar el comportamiento del conjunto, sino decidir si conviene mantener todos los proveedores, reducir el peso de alguno, ajustar el horizonte de evaluación o incluso abandonar el enfoque multi-IA si los datos no justifican su coste.
Con eso ya no hace falta creer que el multi-IA aporta: lo ves, o ves que no, y afinas en consecuencia.
Queda una última puerta abierta, y es de costo y privacidad. Las cuatro IA de esta serie son APIs pagas que mandan tu contexto a un servidor ajeno. En la Parte 5 vamos a sumar un proveedor que corre en tu propia máquina, gratis y offline, y a meterlo en el mismo voto y el mismo scorecard que armamos aquí, para ver cómo se mide un cerebro local contra los de la nube.
Aclaración: marco educativo y de diagnóstico. No es consejo financiero.
Advertencia: todos los derechos de estos materiales pertenecen a MetaQuotes Ltd. Queda totalmente prohibido el copiado total o parcial.
Este artículo ha sido escrito por un usuario del sitio web y refleja su punto de vista personal. MetaQuotes Ltd. no se responsabiliza de la exactitud de la información ofrecida, ni de las posibles consecuencias del uso de las soluciones, estrategias o recomendaciones descritas.
Aprendizaje automático y Data Science (Parte 43): Detección de patrones ocultos en datos de indicadores con modelos de mezcla gaussiana latente (LGMM)
De novato a experto: Sincronizador de períodos de mercado
Particularidades del trabajo con números del tipo double en MQL4
Desarrollo de asesores expertos autooptimizables en MQL5 (Parte 8): Análisis de múltiples estrategias
- Aplicaciones de trading gratuitas
- 8 000+ señales para copiar
- Noticias económicas para analizar los mercados financieros
Usted acepta la política del sitio web y las condiciones de uso