Entrenamiento y modo dirigido por decisiones

El LMS corrige los taps con el error entre la salida del ecualizador y el símbolo que se mandó. El receptor no sabe qué símbolo se mandó: si lo supiera, no haría falta el receptor. Hay tres maneras de conseguir esa referencia. Mandar símbolos que el receptor ya conoce (entrenamiento), usar la propia decisión del slicer como si fuera el símbolo (modo dirigido por decisiones, DD) o cambiar de criterio por uno que no necesite los símbolos (el CMA, a ciegas). En la cadena canal → AGC → ecualizador → slicer las tres ocupan el mismo lugar: el sumador que arma el error que vuelve a los taps.

01 · El error necesita una referencia

La filmina de algoritmos MSEG define el error entre la entrada del slicer y su salida:

$$E_k={\hat{A}}_k-Y_k,{𝒄}_{k+1}={𝒄}_k+\beta E_k{𝒓}_k^{*}$$

con $Y_k$ la salida del ecualizador, ${\hat{A}}_k$ la decisión, ${𝒓}_k$ el contenido del buffer y $\beta$ el paso. De dónde sale el LMS está en su nota; acá importa una sola pieza, el término que se resta. Y agrega una aclaración que decide todo lo que sigue: en la etapa de entrenamiento, el símbolo transmitido reemplaza a la decisión, y en el análisis se supone que no hay errores de decisión, así que da lo mismo usar uno u otro.

Con un retardo en el medio. Un ecualizador causal no puede entregar el símbolo de ahora: lo que sale en el instante $k$ estima el símbolo $A_{k-\Delta }$, mandado $\Delta$ símbolos antes. La referencia tiene, entonces, dos formas:

$$E_k^{\text{ent}}=A_{k-\Delta }-Y_k{E}_k^{\text{DD}}={\hat{A}}_k-Y_k,{\hat{A}}_k=\text{slicer}(Y_k)$$

El resto del lazo no cambia. En el script de clase es una sola línea, Ek = slicer_out - yfilt, y pasar a entrenamiento es cambiar slicer_out por el símbolo conocido. La filmina lo dibuja como un conmutador entre la salida del detector y un bloque «modo de entrenamiento».

02 · El modo de entrenamiento

La filmina de ecualización adaptativa lo cuenta así: durante la adaptación el ecualizador todavía no sigue al canal y el slicer se equivoca mucho, por eso se usa una señal de entrenamiento, una secuencia de símbolos que el receptor conoce. Al principio de la transmisión se manda esa secuencia; después se la reemplaza por las decisiones del detector y empiezan los datos.

Con la referencia verdadera, el LMS minimiza el MSE de verdad, sobre la superficie cuadrática de Wiener, que tiene un solo mínimo. No importa de dónde arranquen los taps ni cuán cerrado esté el ojo: converge. Lo que cuesta es otra cosa.

Cuesta tasa. Los símbolos de entrenamiento ocupan el canal y no llevan información del usuario. Si se entrena con $K_{\text{ent}}$ símbolos cada $K_{\text{trama}}$, la fracción útil es

$$\eta =1-\frac{K_{\text{ent}}}{K_{\text{trama}}}$$

y para mantener la tasa de información hay que subir la de símbolos en $1/\eta$, la misma cuenta que con el overhead del FEC. Cuesta, además, coordinación: el receptor tiene que saber cuándo empieza la secuencia y alinearla con su salida, que es elegir $\Delta$ (sección 06).

Cuántos símbolos. Los que tarde el LMS en abrir el ojo lo suficiente para que la DD pueda seguir sola. Eso lo pone el paso, no el canal solo: es el tiempo de convergencia del LMS. En la cadena del script de clase, con su paso de 2e-3, entrenar todo el tiempo baja la tasa de errores de decisión, en bloques de 10 000 símbolos, así: 0,958 · 0,919 · 0,838 · 0,711 · 0,522 · 0,334 · 0,180 · 0,084 · 0,035. Hacen falta del orden de 70 000 símbolos, unos 2,2 µs a 32 GBd. Con un paso 25 veces más grande, 5e-2, el primer bloque de 10 000 promedia 0,186 y el segundo, cero. Cuánto hace falta exactamente para conmutar sin perderse está medido en las secciones 04 y 07.

03 · El modo dirigido por decisiones

La idea es la del slicer: si el ojo está abierto, la decisión es el símbolo que se mandó. Entonces se la puede usar de referencia, y el ecualizador sigue adaptándose con los datos del usuario sin gastar un símbolo. Por qué funciona, en dos pasos.

Paso 1: cuando la decisión acierta, el error es el mismo. Si ${\hat{A}}_k=A_{k-\Delta }$, entonces $E_k^{\text{DD}}=E_k^{\text{ent}}$ exacto, y la actualización de los taps es idéntica. No es una aproximación: es el mismo número.

Paso 2: la diferencia vive sólo en los errores de decisión. Con una tasa de errores de decisión $p$, una fracción $p$ de las actualizaciones usa una referencia equivocada, y en esas el error es

$$E_k^{\text{DD}}=E_k^{\text{ent}}+({\hat{A}}_k-A_{k-\Delta })$$

El término de más es un salto entre dos puntos de la constelación, de largo 2 o más, y apunta hacia el vecino que el slicer eligió. Con el ojo abierto, $p$ es chico, los saltos son raros y el paso chico del LMS los promedia. Medido con 16-QAM por un canal suave (el modelo de abajo, $\rho =\mathrm{0,15}$), en 200 corridas de 6000 símbolos, MSE en los últimos mil:

Sin errores de decisión los dos modos dan el mismo MSE a todas las cifras, como dice el paso 1. Con un 0,2 % de decisiones erradas difieren en un 0,2 %; con un 2,7 %, en un 2 %. Lo que sobra respecto de Wiener es el desajuste del LMS y es el mismo en los dos modos. Con el ojo abierto, DD es entrenamiento.

04 · Por qué falla con el ojo cerrado

Con el ojo cerrado el paso 2 se da vuelta: la mayoría de las referencias están mal, y los saltos ${\hat{A}}_k-A_{k-\Delta }$ ya no se promedian: tienen dirección. El error apunta hacia donde el slicer decidió, no hacia donde estaba el símbolo, y el ecualizador aprende a reproducir sus propias equivocaciones. Puede quedar en un equilibrio falso, donde las decisiones erradas son consistentes consigo mismas y el error promedio se anula lejos de Wiener.

El modelo. Para medirlo sin nada más en el medio: símbolos a un símbolo por muestra por el canal $h=[\rho ,1,-\rho ]$, ruido de desvío $\sigma =\mathrm{0,1}$ por componente (la semidistancia entre niveles es 1), ecualizador de $N=11$ taps con el central en 1, $\Delta =6$, paso $\beta ={\beta }_{\text{opt}}/5$ con el ${\beta }_{\text{opt}}=1/(N{\phi }_0)$ de la filmina, y 3000 símbolos por corrida. El canal se eligió porque

$$H(e^{j\omega })=e^{-j\omega }(1+2j\rho \mathrm{sen}\omega ),{|H|}^2=1+4{\rho }^2{\mathrm{sen}}^2\omega \ge 1$$

nunca se anula: es ecualizable para cualquier $\rho$, y lo único que $\rho$ mueve es cuán cerrado llega el ojo. Sin ecualizar, la decisión sobre un nivel ve $\rho (A_{k-5}-A_{k-7})$ de ISI, que en el peor caso vale $2\rho (L-1)$ con $L$ niveles por eje. El ojo se cierra cuando eso llega a la semidistancia:

$${\rho }_{\text{cierre}}=\frac{1}{2(L-1)}\text{QPSK: }\mathrm{0,5}\text{16-QAM: }\mathrm{0,167}\text{64-QAM: }\mathrm{0,071}$$

La tasa de errores de decisión al arrancar tiene forma cerrada: con el tap central en 1, cada eje decide $A_{k-6}+\rho (A_{k-5}-A_{k-7})$ más ruido, y se promedia $Q$ sobre las $L^3$ combinaciones. Contra 1000 × 2000 decisiones simuladas difiere en menos de 0,001. DD desde el primer símbolo, 1000 corridas por fila:

«Converge» es que las últimas mil decisiones acierten el 99 % contra $A_{k-\Delta }$. «Otro retardo o giro» es que acierten ese 99 % contra el mismo símbolo corrido hasta tres lugares o girado un múltiplo de 90°: el ojo quedó abierto, pero en otro lugar. Las tres cosas que se leen:

• Con el ojo apenas cerrado, DD igual arranca. 16-QAM con un tercio de decisiones erradas y 64-QAM con casi un cuarto convergen en prácticamente las mil corridas. Con dos tercios o más, se pierde la mayoría de las veces.
• QPSK aguanta más, y cuando falla muchas veces no falla. Decide por signo, así que no depende de la escala. Con el ojo muy cerrado converge seguido a otro retardo o con la constelación girada: equilibrios que para el lazo son tan buenos como el pedido. Es la razón por la que la filmina dice que con PAM-2 o QPSK se puede trabajar con DD.
• Las QAM densas se achican. Cuando no convergen, la salida termina con la escala equivocada. Con 64-QAM y $\rho =\mathrm{0,3}$ el MSE final mediano es 7,2, contra 0,022 con $\rho =\mathrm{0,1}$, donde converge.

El umbral. Lo que importa no es el canal sino cuán abierto está el ojo en el instante en que la DD toma el mando. Se lo mide así: entrenar $K_{\text{ent}}$ símbolos, con $K_{\text{ent}}$ de 0 a 400 de a 10 y 200 corridas cada uno, congelar los taps en el instante de conmutar, medir con ellos la tasa de errores de decisión sobre 2000 símbolos nuevos, y agrupar las corridas por esa tasa:

Entre paréntesis, cuántas corridas cayeron en cada franja; la QPSK de este canal no pasa de 0,4375 de errores, que es su valor sin ecualizar. Hasta 0,4 de decisiones erradas la DD converge casi siempre; de ahí en adelante la probabilidad se cae, y pasado 0,6 se pierde casi siempre. En este modelo el umbral está entre 0,4 y 0,6. En la cadena del script de clase, con la misma cuenta, está entre 0,17 y 0,25 (sección 07). Godard, en el extra 6.1, da la cifra de la literatura de módems: la DD «no converge cuando la probabilidad de error es del orden de 0,1», salvo con modulación de fase pura. No hay un número universal: depende de la cadena, del paso y de hacia dónde están equivocadas las decisiones. La misma tasa puede salvarse o no, como se ve en la sección 06 con la escala. Lo universal es la dirección: DD hereda el ojo con que arranca.

Cuántos símbolos de entrenamiento alcanzan. Con los mismos tres canales, 1000 corridas por celda; entre paréntesis, la mediana de los errores de decisión al conmutar:

Con 100 símbolos convergen las tres en las mil corridas. El entrenamiento no tiene que terminar el trabajo: alcanza con que deje el ojo lo bastante abierto para que la DD lo termine. Con 50 símbolos la 16-QAM conmuta con un 15 % de decisiones erradas y converge siempre. Sin entrenar, la QPSK además termina en otro retardo o giro en el 22,3 % de las corridas.

Con 16-QAM y $\rho =\mathrm{0,15}$ el ojo arranca apenas abierto y la DD sola alcanza: las marcas rojas se apagan en unos cientos de símbolos y las dos curvas de error bajan juntas hasta el piso de Wiener. Llevá $\rho$ a 0,5. La mayoría de las corridas ya no convergen: la franja roja sigue hasta el final, la constelación se achica hacia el centro y el error que ve el LMS queda por debajo del verdadero, porque el slicer siempre elige el punto más cercano y la DD mide contra ese. El receptor no ve el error verdadero, así que no tiene cómo saber que se perdió. Subí ahora el entrenamiento: con 50 símbolos ya convergen todas las corridas probadas en MATLAB, y la marca que separa la franja celeste del resto es el instante en que la DD toma un ojo que ya está abierto. Con QPSK y $\rho$ alto, probá varias semillas: muchas terminan en «otro retardo o giro».

05 · Entrenar y seguir

La receta de la filmina es la del widget: entrenar al principio para adquirir y pasar a DD para seguir. La DD no sólo evita gastar tasa después del arranque; es lo que deja al ecualizador acompañar un canal que cambia. La filmina lo pone como condición: la decisión del slicer como referencia es efectiva «cuando las variaciones de la respuesta del canal son relativamente lentas».

Medido con 16-QAM y 20 000 símbolos, 100 corridas por fila, con el canal que cambia de dos maneras: una rampa lenta de $\rho =\mathrm{0,1}$ a 0,5 a lo largo de toda la corrida, y un salto de 0,1 a 0,5 en la mitad. Tasa de errores de decisión en los últimos 2000 símbolos:

Tres lecturas. Un ecualizador entrenado y congelado queda afinado para el canal de cuando se entrenó; al final de la rampa decide mal la mitad de las veces. La DD sigue la rampa sin un solo error, porque en cada instante el ojo está abierto para el canal de ese instante: nunca arranca con el ojo cerrado, lo mantiene abierto. Y en esta rampa no hacía falta entrenar: con $\rho =\mathrm{0,1}$ al principio, la DD sola arranca. Las dos últimas filas coinciden a todas las cifras, y no por casualidad: con el ojo abierto desde el primer símbolo ninguna decisión del arranque falla, y por el paso 1 de la sección 03 las dos actualizaciones son el mismo número, símbolo por símbolo. El salto es otra cosa. Los taps de $\rho =\mathrm{0,1}$ puestos de golpe frente a un canal de 0,5 dejan el ojo cerrado, y en una de cada cinco corridas la DD no lo recupera. Ahí el receptor tiene que volver a entrenar, y por eso los sistemas que atraviesan desvanecimientos intercalan símbolos conocidos a lo largo de la trama, no sólo al principio.

06 · La inicialización y el retardo

El tap central en 1. Un ecualizador con un solo tap distinto de cero es un cable: deja pasar la señal tal como llega, atrasada. Es la mejor apuesta cuando no se sabe nada del canal, y fija dos cosas a la vez, la escala de arranque y el retardo. Con entrenamiento la escala no importa, porque el error se mide contra el símbolo verdadero y el LMS aprende la ganancia que falte. Con DD importan las dos, porque el error se mide contra lo que el slicer decidió con esa escala y ese retardo.

La escala. Sin ISI ($\rho =0$) y con el tap central en $g$ en vez de 1, DD desde el arranque, 200 corridas por celda:

Con QPSK convergen las seis filas: el signo no depende de la escala. Con las QAM densas la tabla es asimétrica, y eso muestra por qué la tasa de errores sola no decide. $g=\mathrm{0,75}$ y $g=\mathrm{1,5}$ dan, con 64-QAM, la misma tasa de errores al arrancar, 0,750, y terminan al revés. Con la escala corta, todos los puntos caen en las celdas de decisión de adentro; esas decisiones son coherentes con una salida chica, y el error empuja a achicarla más. El equilibrio falso es una constelación reducida: la salida termina en 0,40 veces el tamaño correcto con 16-QAM y en 0,20 con 64-QAM y $g=\mathrm{0,25}$. Con la escala larga, los puntos de afuera se deciden en el nivel extremo, que está más adentro que ellos, y el error tira la ganancia hacia abajo, hacia la correcta.

Por eso el script de clase no arranca en 1 sino en 16. El AGC deja la entrada en 0,1 de valor eficaz y la 64-QAM de qammod tiene valor eficaz $\sqrt{42}\approx \mathrm{6,48}$. El tap de 16 arranca la salida en 1,6: la escala corta de la tabla. Pero arrancar en 65, la escala justa, tampoco alcanza (sección 07): el ojo sigue cerrado por la ISI.

El retardo. Con entrenamiento, $\Delta$ se elige: es el corrimiento entre la secuencia de referencia y la salida. Cada $\Delta$ tiene su propio mínimo de Wiener, y el LMS converge al del $\Delta$ que se le dio, bueno o malo. Con 16-QAM y $\rho =\mathrm{0,5}$, entrenando 6000 símbolos, 50 corridas:

El mejor es $\Delta =6$: el retardo del tap central (5 símbolos) más el del tap principal del canal (1). Así el pico del símbolo buscado cae en el medio del buffer y quedan taps de los dos lados para la ISI de antes y de después. Con $\Delta =1$ el LMS converge igual, a una curva de aprendizaje que se ve estable, y deja la mitad de las decisiones mal. Un retardo mal elegido no da error de ejecución: da un MSE malo. La regla es Δ = posición del tap central + retardo del pico del canal, y en una cadena con filtros se suman sus retardos de grupo, como en la sección 07.

Con DD, en cambio, $\Delta$ no se elige: lo fijan el tap central y el canal, porque el ecualizador empieza como un cable con ese retardo y la DD ajusta alrededor. Si el ojo arranca cerrado puede terminar en otro, como las QPSK de la tabla de la sección 04. Una QAM cuadrada tiene además la ambigüedad de 90°: la constelación girada es la misma constelación, y la DD converge perfecta con todas las decisiones mal. Con símbolos conocidos las dos ambigüedades se resuelven, porque la referencia dice cuál era el símbolo y cuándo. Sin ellos, la nota del CMA cuenta cómo se arranca a ciegas y qué queda sin resolver.

07 · El análisis en MATLAB

El script de clase tal cual. basic_transceiver_DD_equalizer.m es el experimento que la filmina deja planteado —«investigar qué ocurre con modulaciones de mayor orden»—: 64-QAM a 32 GBd, pulso raíz de coseno realzado sólo en el transmisor, $E_b/N_0=21$ dB, canal ch = 1, AGC a 0,1 y un ecualizador fraccionario de 63 taps que se adapta sólo en DD desde el tap central en 16. Corre sin tocar nada (con slicer.m y sus funciones en la misma carpeta), tarda 7 segundos, y con rng(1) antes de llamarlo da ber_aprox = 0.1564 contra ber_teorico = 5.8465e-10: la SER es 0,9382. No converge. La salida termina con valor eficaz 1,17 cuando los símbolos tienen 6,48: es la constelación achicada de la sección 06. No es un error de código: es la respuesta a la pregunta de la filmina.

El mismo lazo, con entrenamiento. El script de abajo es el de clase con una sola línea cambiada: durante los primeros Kent símbolos, la referencia es el símbolo conocido ak(kk-D) en vez de slicer_out. Todo lo demás —filtros, ruido, AGC, paso, fuga de taps, tap inicial— es el script de clase, y con Kent = 0 y rng(1) reproduce su SER a las cuatro cifras. Lo que figura como comentario es la salida real de correrlo en R2026a.

%% El transceptor de basic_transceiver_DD_equalizer.m con un conmutador
%% entrenamiento -> DD. Lo demás es el script de clase: 64-QAM, FSE de 63
%% taps a T/2, step = 2e-3, tap central en 16, AGC a 0.1.
function entrenamiento_dd
set(0, 'DefaultFigureVisible', 'off');

%% 1. Sin entrenamiento es el script de clase: con rng(1) da lo mismo
r = transceptor(64, 16, 0, 1);
fprintf('Kent = 0: SER = %.4f, rms salida = %.2f\n', r.SER, r.rms);
% Kent = 0: SER = 0.9382, rms salida = 1.17

%% 2. La escala del tap inicial
r = transceptor(4, 16, 0, 1);
fprintf('QPSK, tap 16: SER = %.4f\n', r.SER);
% QPSK, tap 16: SER = 0.0000
r = transceptor(64, 65, 0, 1);
fprintf('64-QAM, tap 65: SER al arrancar = %.3f, SER final = %.4f\n', r.SERini, r.SER);
% 64-QAM, tap 65: SER al arrancar = 0.843, SER final = 0.9021

%% 3. Barrido del largo del entrenamiento
for Kent = [20000 40000 60000 65000 70000 75000 80000 100000]
    for semilla = 1:3
        r = transceptor(64, 16, Kent, semilla);
        fprintf('Kent = %6d, semilla %d: SER al conmutar = %.3f, SER final = %.4f\n', ...
                Kent, semilla, r.SERsw, r.SER);
    end
end
% Kent =  20000, semilla 1: SER al conmutar = 0.894, SER final = 0.9462
% Kent =  20000, semilla 2: SER al conmutar = 0.897, SER final = 0.9460
% Kent =  20000, semilla 3: SER al conmutar = 0.895, SER final = 0.9447
% Kent =  40000, semilla 1: SER al conmutar = 0.646, SER final = 0.8846
% Kent =  40000, semilla 2: SER al conmutar = 0.641, SER final = 0.8875
% Kent =  40000, semilla 3: SER al conmutar = 0.618, SER final = 0.8851
% Kent =  60000, semilla 1: SER al conmutar = 0.245, SER final = 0.6570
% Kent =  60000, semilla 2: SER al conmutar = 0.270, SER final = 0.6865
% Kent =  60000, semilla 3: SER al conmutar = 0.274, SER final = 0.6552
% Kent =  65000, semilla 1: SER al conmutar = 0.156, SER final = 0.0072
% Kent =  65000, semilla 2: SER al conmutar = 0.169, SER final = 0.0154
% Kent =  65000, semilla 3: SER al conmutar = 0.170, SER final = 0.0105
% Kent =  70000, semilla 1: SER al conmutar = 0.117, SER final = 0.0013
% Kent =  70000, semilla 2: SER al conmutar = 0.130, SER final = 0.0022
% Kent =  70000, semilla 3: SER al conmutar = 0.114, SER final = 0.0016
% Kent =  75000, semilla 1: SER al conmutar = 0.104, SER final = 0.0007
% Kent =  75000, semilla 2: SER al conmutar = 0.080, SER final = 0.0011
% Kent =  75000, semilla 3: SER al conmutar = 0.088, SER final = 0.0008
% Kent =  80000, semilla 1: SER al conmutar = 0.071, SER final = 0.0005
% Kent =  80000, semilla 2: SER al conmutar = 0.077, SER final = 0.0007
% Kent =  80000, semilla 3: SER al conmutar = 0.051, SER final = 0.0005
% Kent = 100000, semilla 1: SER al conmutar = 0.009, SER final = 0.0004
% Kent = 100000, semilla 2: SER al conmutar = 0.018, SER final = 0.0004
% Kent = 100000, semilla 3: SER al conmutar = 0.013, SER final = 0.0004
end

function r = transceptor(M, tap0, Kent, semilla)
rng(semilla);
BR = 32e9; L = 250000; N = 2; fs = N*BR; EbNo = 21; k = log2(M);
ak  = qammod(randi([0 M-1], L, 1), M);
h   = rcosdesign(0.1, 10, fs/BR, "sqrt");  h = h./sum(h);
ych = filter(h, 1, upsample(ak, N));                % canal ch = 1
SNR = 10^((EbNo - 10*log10(N) + 10*log10(k))/10);
sigma = sqrt(var(ych)/SNR/2);
y   = filter(fir1(3, 0.45), 1, ych + sigma*(randn(size(ych)) + 1j*randn(size(ych))));
yn  = y*(0.1/std(y));                               % AGC

NTAPS = 63; step = 2e-3; leak = 1e-3;
D = 21;             % retardo en símbolos: RRC 10 + AAF 1,5 + tap central 31 = 42,5 muestras
C = zeros(NTAPS, 1); C((NTAPS+1)/2) = tap0;
buffer = zeros(NTAPS, 1);
xk = zeros(L, 1); acierto = zeros(L, 1);
for m = 1:N*L
    buffer(2:end) = buffer(1:end-1); buffer(1) = yn(m);
    yfilt = C.'*buffer;
    if mod(m, N) == 0
        kk = m/N;
        slicer_out = decidir(yfilt, M);             % = slicer.m, sin los if
        if kk > D, acierto(kk) = slicer_out == ak(kk-D); end
        if kk <= Kent && kk > D
            Ek = ak(kk-D) - yfilt;                  % entrenamiento: el símbolo conocido
        else
            Ek = slicer_out - yfilt;                % DD: la decisión del slicer
        end
        C = C*(1 - step*leak) + step.*Ek.*conj(buffer);
        xk(kk) = yfilt;
    end
end
T0 = L/2;                                           % se cuenta en la segunda mitad
r.SER    = 1 - mean(acierto(T0+D:end));
r.SERsw  = 1 - mean(acierto(max(D+1, Kent-999):max(D+1, Kent)));
r.SERini = 1 - mean(acierto(D+1:D+1000));
r.rms    = rms(xk(T0:end));
end

function y = decidir(x, M)
% El slicer de clase por componente: umbrales en los pares, niveles impares.
Lv = sqrt(M);
f = @(v) min(max(2*floor(v/2) + 1, -(Lv-1)), Lv-1);
y = f(real(x)) + 1j*f(imag(x));
end

Lo que dice la salida, bloque por bloque. El 1 es el script de clase, con la misma SER y la salida achicada. En el 2, QPSK converge con el mismo tap de 16, como anuncia la filmina; y 64-QAM con el tap en 65, la escala justa, arranca con el 84,3 % de decisiones erradas y tampoco converge: el problema del script no es sólo la escala. El receptor no tiene filtro adaptado y el ecualizador lo tiene que aprender; hasta que lo aprende, el ojo está cerrado por la ISI del propio pulso. El 3 es el barrido: con 60 000 símbolos de entrenamiento la DD recibe un ojo con un cuarto de decisiones erradas y se pierde; con 65 000 recibe un sexto y converge, todavía asentándose cuando se empieza a contar; con 80 000 o más llega al piso de 0,0004–0,0007. En esta cadena el umbral está entre 0,17 y 0,25, y hacen falta unos 65 000 a 80 000 símbolos con el paso de clase. Son el 26 % a 32 % de los 250 000 de la simulación, que es lo que la sección 02 llama costo en tasa.

Cinco detalles que muerden si no se los conoce:

• El signo del error. La filmina de repaso del LMS escribe $E_k=Y_k-{\hat{A}}_k$ en el diagrama y ${𝒄}_{k+1}={𝒄}_k+\beta E_k{𝒓}_k^{*}$ al lado. Juntas suben por la superficie. Lo coherente es lo de la filmina de MSEG y del script: $E_k={\hat{A}}_k-Y_k$ con el $+$.
• El retardo hay que contarlo. D = 21 sale de sumar retardos de grupo: 10 muestras del RRC de 21 taps, 1,5 del AAF de 4 taps y 31 del tap central, 42,5 muestras a T/2, que son 21 símbolos en los instantes pares. finddelay(ak, ak_hat) también da 21, incluso cuando el ecualizador no convergió: sirve para alinear el conteo, no para diagnosticar. Con D = 20 o 22 el entrenamiento también converge, porque 63 taps dan margen, pero más lento: a los 70 000 símbolos la tasa de errores de decisión es 0,329 y 0,368 contra 0,180 con 21.
• slicer.m es lento. El comentario del script lo dice («este slicer es lentoooo»). El decidir de arriba da exactamente lo mismo —isequal sobre 20 000 puntos al azar— y la corrida baja de 7,2 a 2,3 segundos, que es lo que hace barato el barrido.
• ber_aprox no es la BER. Divide la SER por $k$, que supone un bit errado por símbolo errado. Con SER 0,94 eso no vale; el comentario del script lo avisa: «Uds. calculen el BER como debe ser».
• El paso y el AGC van juntos. Con la entrada en 0,1 de valor eficaz, ${\phi }_0$ es 0,01 y el ${\beta }_{\text{opt}}$ de la filmina para 63 taps es 1,6: el 2e-3 del script es 800 veces más chico. Por eso el entrenamiento tarda decenas de miles de símbolos. La filmina propone un objetivo de AGC de 0,3, que multiplica ${\phi }_0$ por nueve; el paso que se elija tiene que ir con el objetivo que se elija.

Para tener a mano

1. El error del LMS necesita una referencia: $E_k=A_{k-\Delta }-Y_k$ con entrenamiento, $E_k={\hat{A}}_k-Y_k$ en DD. La tercera fuente es el CMA, que no usa símbolos.
2. Entrenar converge siempre pero cuesta $K_{\text{ent}}/K_{\text{trama}}$ de la tasa. Cuántos símbolos hacen falta lo decide el tiempo de convergencia del LMS, o sea el paso.
3. Si la decisión acierta, el error DD es el entrenado, exacto. Con el ojo abierto DD es entrenamiento: mismo MSE, sin gastar símbolos.
4. Con el ojo cerrado, las decisiones erradas tienen dirección y llevan a equilibrios falsos: la QAM densa se achica, la QPSK se corre de retardo o gira. El umbral medido: entre 0,4 y 0,6 de decisiones erradas en el modelo, entre 0,17 y 0,25 en la cadena de clase; Godard da 0,1. No hay número universal.
5. La receta: entrenar para adquirir, DD para seguir. DD sigue un canal que cambia despacio; un salto que cierre el ojo pide reentrenar.
6. El tap central en 1 fija escala y retardo. La escala corta es la peligrosa para DD con QAM densa. $\Delta$ = tap central + pico del canal; con entrenamiento se elige, con DD lo fija la inicialización.
7. El script de clase con 64-QAM no converge en DD (SER 0,938): arranca con el ojo cerrado. Con 65 000 a 80 000 símbolos de entrenamiento antes, sí.