logit-und inverse logit-Funktionen für extreme Werte

Brauche ich logit-und inverse logit-Funktionen, so dass logit(inv_logit(n)) == n. Ich benutze numpy und hier ist was ich habe:

import numpy as np
def logit(p):
    return np.log(p) - np.log(1 - p)

def inv_logit(p):
    return np.exp(p) / (1 + np.exp(p))

Und hier sind die Werte:

print logit(inv_logit(2)) 
2.0 

print logit(inv_logit(10))
10.0 

print logit(inv_logit(20))
20.000000018 #well, pretty close

print logit(inv_logit(50))
Warning: divide by zero encountered in log
inf

Nun testen wir, negative zahlen

print logit(inv_logit(-10))
-10.0 
print logit(inv_logit(-20))
-20.0 
print logit(inv_logit(-200))
-200.0 
print logit(inv_logit(-500))
-500.0 
print logit(inv_logit(-2000))
Warning: divide by zero encountered in log
-inf

Also meine Fragen sind: was ist der richtige Weg, um diese Funktionen zu implementieren, so dass die Anforderung logit(inv_logit(n)) == n halten für jeden n so weit reichen wie möglich (mindestens [-1e4; 1e4)?

Und auch (und ich bin sicher, dies ist mit dem ersten verbunden), warum sind meine Funktion, mehr stabil mit negativen Werten im Vergleich zu den positiven?

InformationsquelleAutor Boris Gorelik | 2012-02-28

floating-point python

Entweder

1.
Die bigfloat-Paket mit unterstützt beliebiger Genauigkeit floating point-Operationen.

2.
Die SymPy symbolischen math-Paket. Ich gebe Beispiele für beide:

Erste, bigfloat:

http://packages.python.org/bigfloat/

Hier ein einfaches Beispiel:

from bigfloat import *
def logit(p):
    with precision(100000):
        return log(p)- log(1 -BigFloat(p))

def inv_logit(p):
    with precision(100000):
        return exp(p) / (1 + exp(p))

int(round(logit(inv_logit(12422.0))))
# gives 12422
int(round(logit(inv_logit(-12422.0))))
# gives -12422

Ist es wirklich langsam. Vielleicht möchten Sie erwägen Umstrukturierung dein problem und einige Teile analytisch. Fälle wie diese sind selten in echte Probleme - ich bin neugierig, welche Art von problem Sie arbeiten.

Beispiel-installation:

wget http://pypi.python.org/packages/source/b/bigfloat/bigfloat-0.3.0a2.tar.gz
tar xvzf bigfloat-0.3.0a2.tar.gz 
cd bigfloat-0.3.0a2
as root:
python setup.py install

Über den Grund Ihrer Funktionen waren besser mit negativen Werten. Bedenken Sie:

>>> float(inv_logit(-15))
3.059022269256247e-07

>>> float(inv_logit(15))
0.9999996940977731

Im ersten Fall Gleitkommazahlen repräsentieren diesen Wert leicht. Der Dezimalpunkt wird so verschoben, dass die führenden Nullen: 0.0000... muss nicht gespeichert werden. Im zweiten Fall werden alle führenden 0.999, die gespeichert werden muss, so müssen Sie alle, dass zusätzliche Präzision, um eine genaue Ergebnis, als später tun, 1-p logit().

Hier ist die symbolic math Weg (deutlich schneller!):

from sympy import *
def inv_logit(p):
    return exp(p) / (1 + exp(p))
def logit(p):
    return log(p)- log(1 -p)

x=Symbol('x')
expr=logit(inv_logit(x))
# expr is now:
# -log(1 - exp(x)/(1 + exp(x))) + log(exp(x)/(1 + exp(x)))
# rewrite it: (there are many other ways to do this. read the doc)
# you may want to make an expansion (of some suitable kind) instead.
expr=cancel(powsimp(expr)).expand()
# it is now 'x'

# just evaluate any expression like this:    
result=expr.subs(x,123.231)

# result is now an equation containing: 123.231
# to get the float: 
result.evalf()

Sympy ist hier zu finden http://docs.sympy.org/. In ubuntu ist es über synaptic.

InformationsquelleAutor

6

Es ist ein Weg, um die Funktionen implementiert, so dass Sie stabil sind, in eine Vielzahl von Werten, sondern es sich um eine Unterscheidung der Fälle, je nach argument.

Nehmen Sie zum Beispiel die inv_logit Funktion. Die Formel "np.exp(p) /(1 + np.exp(p))" ist korrekt, aber ein überlauf für große p. Teilt man Zähler und Nenner durch die np.exp(p) Sie erhalten die entsprechende Ausdruck
```
1. / (1. + np.exp(-p))
```
Dem Unterschied, dass diese nicht überlaufen-für die große positive p. Überlauf wird jedoch für große negative Werte von p. Also, eine stabile Implementierung könnte wie folgt Aussehen:
```
def inv_logit(p):
    if p > 0:
        return 1. / (1. + np.exp(-p))
    elif p <= 0:
        np.exp(p) / (1 + np.exp(p))
    else:
        raise ValueError
```
Dies ist die Strategie, in der Bibliothek LIBLINEAR (und eventuell andere).

InformationsquelleAutor Fabian Pedregosa
1

Läufst du gegen die Präzision Grenzwerte für IEEE 754 double-precision-float. Benötigen Sie eine höhere Genauigkeit zahlen und Operationen-wenn Sie möchten, eine größere Reichweite und eine genauere domain.
```
>>> 1 + np.exp(-37)
1.0
>>> 1 + decimal.Decimal(-37).exp()
Decimal('1.000000000000000085330476257')
```
InformationsquelleAutor Ignacio Vazquez-Abrams
0

Meine Variante von Fabian Pedregosa ' s Antwort:
def stable_inv_logit(x): return 0.5*(1. + np.sign(x)*(2./(1. + np.exp(-np.abs(x))) - 1.))

InformationsquelleAutor user188358

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.