Consigli pratici, per favore. - pagina 5

Nuovo commento
 
Dmitry Fedoseev:
Mod 1 Modo 2 Modo 3 Modo 4 Modo 5 (vi) Modo 6 (vi) Modo 7 (vi) Modo 8 (vi) Mod 9 (vi) Mod 10 (vi) Mod 11 (vi) Mod 12 (viii) mod 13 (vi) 14 Modo 15 Importo
4,43 1 17,09 1 15,82 2 2,53 1 0,63 1 17,72 1 28,48 1 5,70 2 13,29 3 5,70 2 8,23 2 6,33 2 0,63 1 3,16 3 6,96 3 23
5,06 2 17,72 2 12,66 1 3,80 2 0,63 1 19,62 2 29,11 2 4,43 1 9,49 2 5,06 1 6,33 1 6,33 2 1,90 2 1,90 2 6,33 2 26
4,43 1 20,25 3 16,46 3 4,43 3 0,63 1 17,72 1 29,75 3 6,33 3 5,06 1 8,23 3 10,13 3 5,06 1 0,63 1 1,27 1 4,43 1 29


La somma più bassa è 23, scegliendo la prima riga.

Grazie, prenderò nota anche di questo.

Ma questi sono valori di errore, è affidabile usare questo metodo di stima del rating?
In statistica, usano principalmente la somma dei quadrati per stimare gli errori.
E la somma dei quadrati e la valutazione hanno risultati diversi, quindi di quale metodo fidarsi?

;))

In quale area matematica si usa il metodo della classifica?
Per fumare questo materiale e capire dove viene usato.
 

Il metodo utilizzato dovrebbe essere quello che dà una soluzione soddisfacente al problema in questione. Quando si applica qualsiasi metodo, bisogna capire cosa si fa e cosa si ottiene.

Se non avete idea di quale dovrebbe essere un risultato soddisfacente, non fa differenza quale metodo usare.

 
Dmitry Fedoseev:

Il metodo utilizzato dovrebbe essere quello che dà una soluzione soddisfacente al problema in questione. Quando si applica qualsiasi metodo, bisogna capire cosa si fa e cosa si ottiene.

E se non avete idea di quale dovrebbe essere un risultato soddisfacente, non fa differenza quale metodo usare.

Sono d'accordo in parte, ma in questo caso stiamo valutando il valore dell'errore stesso e non la sua ricorrenza in un modulo.
Questo metodo è adatto per valutare i valori ripetuti.
Non credo che sia il metodo giusto per valutare i valori di errore stessi.

 
Roman:

Sono parzialmente d'accordo, ma in questo caso stiamo valutando l'errore stesso, non la sua ricorrenza in un modulo.
Questo metodo è adatto alla valutazione di valori ricorrenti.
Non credo che sia il metodo giusto per valutare i valori di errore stessi.

Se i valori sono ripetitivi, daranno esattamente lo stesso risultato che scambiandoli con 1, 2 e 3.

Leggete il primo post di questo thread, lì l'autore del thread ha formulato il suo problema - basta leggerlo, non inventarlo.

 
Dmitry Fedoseev:

Se i valori sono ripetitivi, essi stessi daranno esattamente lo stesso risultato che scambiandoli con 1, 2, 3.

Leggete il primo post di questo thread, dove l'autore del thread ha formulato il suo problema - basta leggerlo, non inventarlo.

Quindi nessuno se lo sta inventando. Come ho capito dal primo post, il compito originale era quello di stimare la minimizzazione dell'errore.
E l'autore nella sua tabella ha persino ricavato la media di tutti gli errori. Ma non pensava che fosse pratico o informativo.
Stimare la minimizzazione dell'errore e stimare i valori di ripetizione sono compiti diversi.

 
Roman:

Quindi nessuno se lo sta inventando. Come ho capito dal primo post, l'obiettivo originale era la minimizzazione dell'errore di stima.
E il topicstarter ha anche fatto una media di tutti gli errori della sua tabella. Ma non pensava che fosse pratico o informativo.
Stimare la minimizzazione dell'errore e stimare i valori ricorrenti sono compiti diversi.

Usare solo la media non è sufficiente, bisogna anche evitare un grande overshoot.

 
Dmitry Fedoseev:

Non basta avere una media, bisogna anche avere un basso tasso di espulsione.

e quindi il prodotto

 
Dmitry Fedoseev:

Non basta usare solo la media, bisogna anche evitare i grandi outlier.

Allora dovreste preparare ulteriormente i dati di input, normalizzarli o standardizzarli.
Nel mio esempio questo è preso in considerazione da MathPow(arr[i] - (max-min)/* o avg*/, 2.0), e il prodotto è eseguito dalla funzione square.
Cioè, lo porta alla seconda potenza, che corrisponde al prodotto.

 

Visto che siamo in tema di normalizzazione e standardizzazione, questo allineamento si applica quando i valori da confrontare devono essere portati alla stessa scala.
Cosa intende per "normalizzare alla stessa scala"?
Per esempio, quando abbiamo bisogno di confrontare numeri come 81,500 e 1,13453 o 5200,1 o 27340 ecc.
Cioè, i valori hanno un numero diverso di cifre dopo il numero intero.
Per confrontare tali dati o passarli in un modello, se il modello ha diversi segni, applicare la normalizzazione o la standardizzazione,
, in modo che il modello calcoli correttamente e produca il calcolo corretto.
Ho scritto tali funzioni, se qualcuno ne ha bisogno, per favore usatele.

//--------------------------------------------------------------------
//Возвращает максимальное значение элементов массива
double ArrayMax(double & arrIn[])
{
   uint size = ArraySize(arrIn);
   if(size == 0) 
      return(0.0);          
   
   double max = arrIn[0];
   for(uint i=1; i<size; i++)
      if(arrIn[i] > max) 
         max = arrIn[i];

   return(max);
}

//--------------------------------------------------------------------
//Возвращает минимальное значение элементов массива
double ArrayMin(double & arrIn[])
{
   uint size = ArraySize(arrIn);
   if(size == 0) 
      return(0.0);   
   
   double min = arrIn[0];  
   for(uint i=1; i<size; i++)
      if(arrIn[i] < min) 
         min = arrIn[i];

   return(min);
}

//--------------------------------------------------------------------
//Возвращает средне арефметическое значение элементов массива
double ArrayMean(double & arrIn[])
{
   uint size = ArraySize(arrIn);
   if(size == 0) 
      return(0.0);         

   double sum = 0.0;       
   for(uint i=0; i<size; i++) 
      sum += arrIn[i];     
   
   return(sum/size);
}

//--------------------------------------------------------------------
//Возвращает среднеквадратичное (стандартное) отклонение значений элементов массива
double ArrayStd(double & arrIn[])
{
   uint size = ArraySize(arrIn);
   if(size == 0) 
      return(0.0);   
   
   double sum  = 0.0; 
   double mean = ArrayMean(arrIn); 
          
   for(uint i=0; i<size; i++)
      sum += MathPow(MathAbs(arrIn[i]-mean), 2.0);
      
   return(MathSqrt(sum/size));
}

//--------------------------------------------------------------------
//Возвращает нормализованные значения элементов масcива
void ArrayNormalized(double & arrIn[], double & arrOut[])
{
   uint size = ArraySize(arrIn);
   if(size == 0) 
      return; 
      
   double min = ArrayMin(arrIn);   
   double max = ArrayMax(arrIn);
   
   for(uint i=0; i<size; i++)
      arrOut[i] = (arrIn[i]-min) / (max-min);   
}

//--------------------------------------------------------------------
//Возвращает стандвртизированые значения элементов масcива
void ArrayStandardized(double & arrIn[], double & arrOut[])
{
   uint size = ArraySize(arrIn);
   if(size == 0) 
      return; 
      
   double mean = ArrayMean(arrIn);
   double std  = ArrayStd(arrIn);
   
   for(uint i=0; i<size; i++)
      arrOut[i] = (arrIn[i]-mean) / std;   
}
 
Roman:

Visto che siamo in tema di normalizzazione e standardizzazione, questo allineamento si applica quando i valori da confrontare devono essere portati alla stessa scala.
Cosa intende per "normalizzare alla stessa scala"?
Per esempio, quando abbiamo bisogno di confrontare numeri come 81,500 e 1,13453 o 5200,1 o 27340 ecc.
Cioè, i valori hanno un numero diverso di cifre dopo il numero intero.
Per confrontare tali dati o passarli in un modello, se il modello ha diversi segni, applicare la normalizzazione o la standardizzazione,
, in modo che il modello calcoli correttamente e produca il calcolo corretto.
Ho scritto tali funzioni, se qualcuno ne ha bisogno, per favore usatele.

Perché non ti piacciono ArrayMaximum e ArrayMinimum? Perché hai dovuto scriverlo attraverso un ciclo?
1234567
Nuovo commento