Overfitting (5 lettori)

pprllo

Nuovo forumer
Vabbe' ma pensavo che la matrice delle condizioni fosse piu' incasinata. :D

Quella che hai scritto e' traducibile in linguaggio naturale. :D

Tutti i parametri sono maggiori di 0.
Tutti i parametri sono inferiori a 1.

Poi la prima riga e' "la somma dei parametri e' maggiore di 1" e l'ultima e' "la somma dei parametri e' minore di 1", mi sa che devi sceglierne una. O forse ti serve "la somma dei parametri e' uguale a 1" ?
 
Ultima modifica:

Cren

Forumer storico
:ciuchino::ciuchino:

:mmmm::mmmm:
Abbi pietà, sto facendo tre cose alla volta, non mi si può pretendere di controllare tutto minuziosamente quando faccio partire qualcosa :lol:
Vabbe' ma pensavo che la matrice delle condizioni fosse piu' incasinata. :D

Quella che hai scritto e' traducibile in linguaggio naturale. :D

Tutti i parametri sono maggiori di 0.
Tutti i parametri sono inferiori a 1.

Poi la prima riga e' "la somma dei parametri e' maggiore di 1" e l'ultima e' "la somma dei parametri e' minore di 1", mi sa che devi sceglierne una. :D
Infatti, però l'algoritmo esprime i vincoli sotto una condizione di "≥" e quindi pensavo in quel modo di esprimere l'uguaglianza ad 1.

Però mi sa che così non sa da dove partire.
 

pprllo

Nuovo forumer
Però mi sa che così non sa da dove partire.
Mah, purche' usi un rilassamento semplice e non un sovrarilassamento (cioe' purche' non usi la epsilon) dovrebbe andare. Se usi un sovrarilassamento si inceppa sicuro. :D

PS: Facendo girare l'algoritmo senza epsilon partendo da (0, 0, 0, 0, 0, 0, 0, 0, 0, 0) mi restituisce la soluzione "banale" (0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1), partendo da (0, 0, 0.5, 0, 0, 0, 0, 0, 0, 0) mi restituisce (0.05, 0.05, 0.55, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05), in generale converge in pochi millisecondi da dovunque parto.

Se ti intendi vagamente di C e/o linguaggi procedurali, questo e' il codice (si lo so che e' fetentissimo, l'ho scritto in 10 minuti secchi):
Codice:
#include <cstdlib>
#include <iostream>

using namespace std;

double scalar(double *a, double *b, int i)
{
       double sum = 0;
       for(i--;i >= 0; i--)
              sum += a[i] * b[i];
       return sum;
}

void vsum(double *a, double *b, int i)
{
       for(i--;i >= 0; i--)
                 a[i] += b[i];
}

void vprod(double *a, double b, int i)
{
       for(i--;i >= 0; i--)
                 a[i] *= b;
}

void vcopy(double *a, double *b, int i)
{
       for(i--;i >= 0; i--)
                 a[i] = b[i];
}

double vmod(double *a, int i)
{
       double sum = 0;
       for(i--;i >= 0; i--)
              sum += a[i] * a[i];
       return sum;
}
     
int main(int argc, char *argv[])
{   
    double vect[10] = {0, 0.4, 0.5, 0, 0.2, 0.5, 2, 0, 0, 0};
    
    double a[22][10] = {{1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, 
                             {1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                             {0, 1, 0, 0, 0, 0, 0, 0, 0, 0},
                             {0, 0, 1, 0, 0, 0, 0, 0, 0, 0},
                             {0, 0, 0, 1, 0, 0, 0, 0, 0, 0},
                             {0, 0, 0, 0, 1, 0, 0, 0, 0, 0},
                             {0, 0, 0, 0, 0, 1, 0, 0, 0, 0},
                             {0, 0, 0, 0, 0, 0, 1, 0, 0, 0},
                             {0, 0, 0, 0, 0, 0, 0, 1, 0, 0},
                             {0, 0, 0, 0, 0, 0, 0, 0, 1, 0},
                             {0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
                             {-1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                             {0, -1, 0, 0, 0, 0, 0, 0, 0, 0},
                             {0, 0, -1, 0, 0, 0, 0, 0, 0, 0},
                             {0, 0, 0, -1, 0, 0, 0, 0, 0, 0},
                             {0, 0, 0, 0, -1, 0, 0, 0, 0, 0},
                             {0, 0, 0, 0, 0, -1, 0, 0, 0, 0},
                             {0, 0, 0, 0, 0, 0, -1, 0, 0, 0},
                             {0, 0, 0, 0, 0, 0, 0, -1, 0, 0},
                             {0, 0, 0, 0, 0, 0, 0, 0, -1, 0},
                             {0, 0, 0, 0, 0, 0, 0, 0, 0, -1},
                             {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1}};
    
    double b[22] = {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
    
    bool NotOk = true;
    while (NotOk)
    {
          NotOk = false;
          for (int i = 0; i < 22; i++)
          {
              double d = scalar(vect, a[i], 10) - b[i];
              if (d < 0)
              {
                    NotOk = true;
                    double temp[10];
                    vcopy(temp, a[i], 10);
                    d = - d / vmod(temp, 10);
                    vprod(temp, d, 10);
                    vsum(vect, temp, 10);
              }
          }
    }
    
    for (int i = 0; i < 10; i ++)
        cout << vect[i] << " ";
    cout << endl << endl;

               
    system("PAUSE");
    return EXIT_SUCCESS;
}
 
Ultima modifica:

Paolo1956

Forumer attivo
Vabbe' ma pensavo che la matrice delle condizioni fosse piu' incasinata. :D

Quella che hai scritto e' traducibile in linguaggio naturale. :D

Tutti i parametri sono maggiori di 0.
Tutti i parametri sono inferiori a 1.

Poi la prima riga e' "la somma dei parametri e' maggiore di 1" e l'ultima e' "la somma dei parametri e' minore di 1", mi sa che devi sceglierne una. O forse ti serve "la somma dei parametri e' uguale a 1" ?

Ergo, se leviamo la prima eq.,

la regione ammissibile è un tetraedro di lato unitario con vertice nell'origine...
 

Cren

Forumer storico
Ergo, se leviamo la prima eq.,

la regione ammissibile è un tetraedro di lato unitario con vertice nell'origine...
Raga', sostituite pure nel vettore dei vincoli 0.99 al primo elemento e -1.1 all'ultimo, ma a me col rilassamento non esce comunque un valore ammissibile :sad:

Cosa sbaglio?

...

Zitti tutti, sta elaborando...
 
Ultima modifica:

pprllo

Nuovo forumer
Raga', sostituite pure nel vettore dei vincoli 0.99 al primo elemento e -1.1 all'ultimo, ma a me col rilassamento non esce comunque un valore ammissibile :sad:

Cosa sbaglio?

...

Zitti tutti, sta elaborando...
Vedi il mio post precedente. :D
 
Ultima modifica:

Users who are viewing this thread

Alto