Overfitting

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:
: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.
 
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:
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...
 
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:
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

Back
Alto