Kansrekening probleempje

[Kaw]

Beste tweakbroeders ,

Ik zit echt al weken te zweten op het volgende probleem:
Ik moet een bit 'gokken' en het gaat strikt genomen niet om de bit zelf, maar op de kans dat de bit de gezochte bit is. Dus met andere woorden P(bit_1), P(bit_0) = 1 - P(bit_1), dus hoef ik alleen P(bit_1) te hebben.

De software die ik heb geschreven levert een variabel aantal testen op en die testen hebben allemaal hun eigen bekende nauwkeurigheid.
Een voorbeeldoutput zou kunnen zijn:
Test 1: 70% betrouwbaar, output = 1
Test 2: 60% betrouwbaar, output = 0
Test 3: 55% betrouwbaar, output = 0
Test 4: 55% betrouwbaar, output = 1

Wat ook kan zijn is dat de software 3000 testresultaten oplevert met elk verschillende betrouwbaarheid en compleet tegengestelde waarden zoals:
Test 1: 90% betrouwbaar, output = 1
Test 2: 90% betrouwbaar, output = 0
Test 3: 75% betrouwbaar, output = 0
Test 4: 75% betrouwbaar, output = 1
..
Test 2999: 51% betrouwbaar, output = 0
Test 3000: 51% betrouwbaar, output = 0

Hoe kan ik uit deze gegevens berekenen wat de kans is op P(bit_1) en daarvan afgeleid P(bit_0)?

Zelf heb ik al het één en ander geprobeerd en het klopt nooit. Googelen levert me ook niets op, want ik heb geen idee hoe deze situatie wetenschappelijk genoemd wordt. Met theorie van Bayes bijv. zie ik niet hoe ik die toe moet passen.

Alvast bedankt voor de hulp!

[Pete]

Wat voor testen zijn het precies? Zijn het testen die een percentage als output geven?

Wat je nu zou kunnen doen is als je N tests hebt: P(bit_1) = 1/N * betrouwbaar_1 * output_1 * ...* betrouwbaar_N * output_N

Het hangt wel allemaal af hoe de kansverdeling van die testen is.

[ Voor 13% gewijzigd door Pete op 09-03-2009 16:16 ]

[BCC]

Begin eerst eens met 10.000 tests te draaien en de resulaten te middelen en te plotten in een grafiek en kijk dan welke vorm die heeft.

[Kaw]

Pete schreef op maandag 09 maart 2009 @ 16:15:
Wat voor testen zijn het precies? Zijn het testen die een percentage als output geven?

Nee, een 0 of 1.

Het hangt wel allemaal af hoe de kansverdeling van die testen is.

Bernoulli-verdeling? Het is succes of fail. Heb hier geen verstand van. De nauwkeurigheid van de testen beoordeel ik op in het verleden behaalde resultaten. succes / totaal = betrouwbaarheid (0..1) zeg maar.

Wat je nu zou kunnen doen is als je N tests hebt: P(bit_1) = 1/N * betrouwbaar_1 * output_1 * ...* betrouwbaar_N * output_N

Heb je met het voorgaande informatie nog steeds het idee dat het zo kan? Dan implementeer ik het.

[Kaw]

BCC schreef op maandag 09 maart 2009 @ 16:19:
Begin eerst eens met 10.000 tests te draaien en de resulaten te middelen en te plotten in een grafiek en kijk dan welke vorm die heeft.

Dat wordt lastig denk ik, omdat per bit de gebruikte testen zeer verschillen.

[ Voor 4% gewijzigd door Kaw op 09-03-2009 16:26 ]

[Dido]

Mijn eerste gedachte was inderdaad meteen Bayes.

De ontbrekende informatie is dan hoevaak de resulterende uitkomst voorkomt in de populatie. Met andere woorden, is de kans dat de onderzochte bits 1 of 0 zijn gelijk?

[Kaw]

Dido schreef op maandag 09 maart 2009 @ 16:30:
Mijn eerste gedachte was inderdaad meteen Bayes.

De ontbrekende informatie is dan hoevaak de resulterende uitkomst voorkomt in de populatie. Met andere woorden, is de kans dat de onderzochte bits 1 of 0 zijn gelijk?

Wanneer je de tests buiten beschouwing laat: ja.

[KabouterSuper]

Mmmmm....beetje wazig probleem. Wat ik zelf zou doen is:

* Zie de tests als normale variabelen met gemiddelde =<uitkomst test> en variantie=<zo berekend dat kans op bit-switch=1 - betrouwbaarheid>.
* Kijk vervolgens naar gemiddelde en variantie van de som van de variabelen (deze is ook normaal verdeeld).
Je output is dan 0 als gemiddelde <=0.5 en 1 anders. Je betrouwbaarheid volgt uit het gemiddelde en variantie.

-----------------------------------------------------------------------
Edit: dit is iets te kort door de bocht, omdat het de betrouwbaarheid niet lekker meeneemt (je gemiddelde is een ongewogen som, en dit doet geen recht aan de betrouwbaarheid van verschillende testen).

Poging 2 dus maar:
* voor het gemak heb ik een functie B(x) die nul is als x<=0.5 en 1 anders.
* Zie de tests als normale variabelen met variantie=1 en gemiddelde = <zo berekend dat B(gemiddelde)=uitkomst test en kans op bit-switch=1 - betrouwbaarheid>.
* Kijk vervolgens naar gemiddelde en variantie van (som van de variabelen)/<aantal tests> (deze is ook normaal verdeeld).
Je output is dan B(gemiddelde). Je betrouwbaarheid volgt uit het gemiddelde en variantie.

[ Voor 47% gewijzigd door KabouterSuper op 09-03-2009 16:50 ]

[Pete]

Kaw schreef op maandag 09 maart 2009 @ 16:22:
[...]

Heb je met het voorgaande informatie nog steeds het idee dat het zo kan? Dan implementeer ik het.

Jazeker. Het is dan een gewogen gemiddelde.

Waarom probeer je niet met je testdata wat goed werkt? Heb je wel testdata?

[Kaw]

KabouterSuper schreef op maandag 09 maart 2009 @ 16:37:
Mmmmm....beetje wazig probleem.

Het heeft te maken met datacompressie. Ik kan met mijn programma voor een gemiddeld tekstbestandje 95% van de bits goed inschatten. Dat is niet de kunst in deze situatie. Wanneer je arithmetic coding gebruikt als ondergrond om je inschattingen op te slaan, dan is het juist schatten van de bit haast nog ondergeschikt aan het inschatten hoe zeker je het weet dat je inschatting klopt.

Wat ik zelf zou doen is:

* Zie de tests als normale variabelen met gemiddelde =<uitkomst test> en variantie=<zo berekend dat kans op bit-switch=1 - betrouwbaarheid>.
* Kijk vervolgens naar gemiddelde en variantie van de som van de variabelen (deze is ook normaal verdeeld).
Je output is dan 0 als gemiddelde <=0.5 en 1 anders. Je betrouwbaarheid volgt uit het gemiddelde en variantie.

Eerlijk gezegd snap ik niet hoe dit zou moeten bijdragen aan de oplossing van de vraagstelling. Dat zal aan mij liggen, want deze stof is geheel nieuw voor mij.

[Kaw]

Pete schreef op maandag 09 maart 2009 @ 16:49:
[...]


Jazeker. Het is dan een gewogen gemiddelde.

Waarom probeer je niet met je testdata wat goed werkt? Heb je wel testdata?

Ik ga het vanavond proberen. Het is een privé-programma en ik zit nu nog op mijn werk. Elk bestand op mijn pc is in feite testdata, dus plenty to test

[Dido]

Kaw schreef op maandag 09 maart 2009 @ 16:32:
Wanneer je de tests buiten beschouwing laat: ja.

Dan is Bayes opeens een stuk minder eng.

Stel dat ik een populatie van 100 bits heb, waarvan de helft 1, de helft 0 is.

Als ik dan zo'n testresultaat interpreteer van 70% betrouwbaar, output = 1.

Mijn geteste bit kan dan uit de groep van 50 enen komen. Als dat zo was dan gaat dat voor 35 van die 50 op (70% op een true positive).
Mijn geteste bit kan ook uit de groep nullen komen, dat gaat voor 15 op de 50 op. (30% kans op een false positive).

De kans dat die bit dus daadwerkelijk 1 is, is 35/50, oftewel 70%. Heel schokkend is dat niet, maar de gein is natuurlijk dat je bij een niet-gelijke kans (a priori) op een 1 of een 0 heel andere resultaten krijgt.

Verder is het duidelijk dat een test met een betrouwbaarheid van 1% met als uitkomst een 1 betekent dat je 99% kans hebt dat het in werkelijkheid een 0 betreft.

Het lijkt me dat als je alle testresultaten gewoon weegt, je een betrouwbare uitkomst moet kunnen krijgen.

Dus:

Test 1: 70% betrouwbaar, output = 1
Test 2: 60% betrouwbaar, output = 0
Test 3: 55% betrouwbaar, output = 0
Test 4: 55% betrouwbaar, output = 1

Wordt voor de enen: 70 + 40 + 45 + 55 = 210
Wordt voor de nullen: 30 + 60 + 55 + 45 = 190

De kans lijkt me dan 210/400 (52,5%) op een 1, en 190/400 (=47,5%) op een 0.

[KabouterSuper]

Idee erachter komt uit de electrotechniek. Je verstuurt een bit door de ether, maar dat bit kan omslaan (bit-switch) als er teveel ruis is. In andere woorden, verstuurt een 0 of 1 (of liever gezegd een 1 of -1), maar ontvangt een float. Als de ruis klein is, dan kan je het oorspronkelijke bit nog reconstrueren (als je 0.9 ontvangt, dan kan je met redelijke zekerheid zeggen dat het oorspronkelijk een 1 was). Als de ruis groot is, dan gaat het wel eens fout. Door te veronderstellen dat de ruis een normale verdeling volgt, kan je vervolgens zinnige dingen zeggen over de foutkansen.

Maar probeer eerst maar eens de aanpak van Pete.

Nog een leuk criterium om te testen of je kans zuiver bepaald wordt: Een test met zekerheid 100%. Hieruit zou moeten volgen dat de kans P(bit_1)=100% of 0%. (Pete's methode zal dat niet geven)

--------------------------------------------------------------------------------------------------
Toevoeging: ik heb het idee even uitgewerkt in een Excel sheet, en het werkt prima. Laat maar even weten of je geinteresseerd bent, dan mail ik het wel even.

[ Voor 15% gewijzigd door KabouterSuper op 09-03-2009 21:39 ]

[Kaw]

Pete schreef op maandag 09 maart 2009 @ 16:49:
[...]


Jazeker. Het is dan een gewogen gemiddelde.

Waarom probeer je niet met je testdata wat goed werkt? Heb je wel testdata?

Hummm, ik heb vanavond zitten testen en de redesign van het systeem heeft goed uitgepakt.
Wat me opvalt is dat wanneer ik de beste testen zwaarder weeg dan je zou doen bij een gewogen gemiddelde, dat dit zeer sterk het resultaat verbeterd. Het lijkt er op dat hier geen sprake is van een lineair verband. Het aantal goed functionerende testen is vele malen kleiner dan de matig functionerende testen. Zo kun je 1 hebben die 0.99 scoort en 1000 die 0.51 scoren, maar de invloed van die 1ne met 0.99 die 1 voorspelt valt dan weg bij die 1000 0.51 tests die 0 voorspellen en dat verzwakt het algoritme. Ik heb door wat prutsen de best functionerende tests meer gewicht gegeven, maar het blijft prutsen zonder enige basis.

Enig idee wat hier aan de hand zou kunnen zijn?

[BCC]

Zonder concrete voorbeelden blijft het voor ons natuurlijk een beetje koffiedik kijken.

[Pete]

Kaw schreef op maandag 09 maart 2009 @ 22:33:
[...]

Hummm, ik heb vanavond zitten testen en de redesign van het systeem heeft goed uitgepakt.
Wat me opvalt is dat wanneer ik de beste testen zwaarder weeg dan je zou doen bij een gewogen gemiddelde, dat dit zeer sterk het resultaat verbeterd. Het lijkt er op dat hier geen sprake is van een lineair verband. Het aantal goed functionerende testen is vele malen kleiner dan de matig functionerende testen. Zo kun je 1 hebben die 0.99 scoort en 1000 die 0.51 scoren, maar de invloed van die 1ne met 0.99 die 1 voorspelt valt dan weg bij die 1000 0.51 tests die 0 voorspellen en dat verzwakt het algoritme. Ik heb door wat prutsen de best functionerende tests meer gewicht gegeven, maar het blijft prutsen zonder enige basis.

Enig idee wat hier aan de hand zou kunnen zijn?

Jazeker een idee, je tests kloppen niet of zijn niet onanfhankelijk. Als je tests zouden kloppen dan zouden 1000 tests met 0.51 betrouwbaarheid ongeveer 510x een 1 geven en 490x een 0. Uiteraard kan het gebeuren dat je 1000 x 0 hebt, maar als de tests onafhankelijk zijn is die kans minimaal.

Het klopt dat de minder betrouwbare tests de score naar beneden halen, maar als het goed is komt het nooit onder het gemiddelde. Het idee hierachter is dat je ook onbetrouwbare tests gebruikt in je berekening en daardoor minder zeker word van de totale uitkomst.

[ Voor 4% gewijzigd door Pete op 10-03-2009 05:19 ]

[Kaw]

Ik heb het overdacht en ik weet waar het fout gaat. Een gewogen gemiddelde werkt in het volgende geval prima:
Je hebt 100 man. Je weet van te voren dat 99 man je in 50% van de gevallen de waarheid zal vertellen en 1 man vertelt de waarheid. Dan is de kans dat je gemiddeld de waarheid hebt gehoord: 99 * 0.5 = 49,5 + 1 * 1 = 50,5 / 100 = 0.505. Zo werkt het systeem nu, maar dat klopt niet.

Stel dat je weet welke persoon de waarheid vertelt en welke personen dat in 50% van de keren doen. Dat is bij mijn programma het geval. Gevoelsmatig hoef ik dan alleen maar naar die persoon te luisteren om de juiste uitkomst te krijgen en de 99 andere kan ik negeren.

Nu zijn mijn testen niet zo nauwkeurig, maar je kunt wel hebben dat 99 man die 51% van de keren de waarheid vertellen en 1 man die 99.9% van de keren de waarheid vertellen, dat je dan niet voor ongeveer 0.505 weet wat de waarheid is, maar eerder 98% in de praktijk met je eigen logische verstand.

[Pete]

Nee, niet. Met een gewogen gemiddelde ga je er vanuit dat de betrouwbaarheidspercentages van je tests kloppen en dat de tests onafhankelijk zijn. Als dat het geval is dan kun je de betrouwbaarheid van je conclusie vergroten met de minder betrouwbare tests.

Denk goed na of je tests inderdaad onafhankelijk zijn. En hoe betrouwbaar de betrouwbaarheidspercentages zijn.

[Kaw]

Pete schreef op dinsdag 10 maart 2009 @ 08:11:
Nee, niet. Met een gewogen gemiddelde ga je er vanuit dat de betrouwbaarheidspercentages van je tests kloppen en dat de tests onafhankelijk zijn. Als dat het geval is dan kun je de betrouwbaarheid van je conclusie vergroten met de minder betrouwbare tests.

Denk goed na of je tests inderdaad onafhankelijk zijn. En hoe betrouwbaar de betrouwbaarheidspercentages zijn.

Als ik enkel de meest nauwkeurige test pak en die als uitgangspunt neem voor mijn inschatting, dan krijg ik een resultaat die overeenstemt met de verwachting die past bij die test. De tests kloppen proefondervindelijk.

Als een gewogen gemiddelde toepasbaar is met deze situatie, dan reken ik het gewogen gemiddelde gewoonweg verkeerd uit. Ik pak nog 1 keer het vorige voorbeeld. Stel dat je het doet zoals op wikipedia: Wikipedia: Gewogen gemiddelde en je hebt dus (99 * 0.5) + (1 * 1) / (100) = 0.505 en ik heb al uitgelegd waarom deze uitkomst niet klopt met de werkelijkheid. Ook in de werkelijkheid zou iemand dan geen 0.505 inschatten, maar gewoon 1.

Ander voorbeeldje: (1 * 0.51 en 1 * 0.99) / 2 = 0.75, maar ik weet dat als ik 0.99 alleen neem, dat dit dan ook klopt als ondergrens. De kans is ook > 0.99.
Stel je hebt twee personen. 1 spreekt bijna altijd de waarheid en de ander spreekt iets vaker de waarheid dan dat hij liegt. Stel dat beide personen hetzelfde beweren. Dan is dat niet 0.75 maar juist >0.99. Als de eerlijke iets anders beweert dan degene die heel soms de waarheid vertelt, dan is je menselijke inschatting nog steeds >0.75 en dat klopt ook. De 0.99 wordt door persoon 2 maar ietsje naar beneden getrokken.

[Dido]

En toch is er wel iets aan de hand met hoe je de resultaten onderling weegt.

Een test die 50% betrouwbaar is, bij een populatie waar de 1en en de 0en 50/50 verdeeld zijn, voegt namelijk totaal geen nieuwe informatie toe. Dus als ik 1000 keer een test met een betrouwbaarheid van 50% heb en eentje met een betrouwbaarheid van 90%, dan zal je alleen die laatste in je schatting moeten betrekken - het rekening houden met de 1000 tests die geen informatie toevoegen is alleen maar ruis.

edit: waar ik nog even over twijfel is of je een test die 10% betrouwbaar is en een 1 oplevert mag interpreteren als een 90% betrouwbare test die een 0 oplevert. Ik denk het wel.
Je kunt dan al je tests herschrijven naar een betrouwbaarheid >= 50%, waarna je je weging moet afstemmen op het feit dat een 100% betrouwbare test altijd gelijk heeft en een 50% betrouwbare test genegeerd moet worden.

[ Voor 29% gewijzigd door Dido op 10-03-2009 10:10 ]

[Kaw]

Dido schreef op dinsdag 10 maart 2009 @ 10:07:
En toch is er wel iets aan de hand met hoe je de resultaten onderling weegt.

Een test die 50% betrouwbaar is, bij een populatie waar de 1en en de 0en 50/50 verdeeld zijn, voegt namelijk totaal geen nieuwe informatie toe. Dus als ik 1000 keer een test met een betrouwbaarheid van 50% heb en eentje met een betrouwbaarheid van 90%, dan zal je alleen die laatste in je schatting moeten betrekken - het rekening houden met de 1000 tests die geen informatie toevoegen is alleen maar ruis.

edit: waar ik nog even over twijfel is of je een test die 10% betrouwbaar is en een 1 oplevert mag interpreteren als een 90% betrouwbare test die een 0 oplevert. Ik denk het wel.
Je kunt dan al je tests herschrijven naar een betrouwbaarheid >= 50%, waarna je je weging moet afstemmen op het feit dat een 100% betrouwbare test altijd gelijk heeft en een 50% betrouwbare test genegeerd moet worden.

Alle testen zijn al >50% betrouwbaar en in mijn voorbeelden heb ik dat ook gedaan. Dat van die 50% heb ik alleen gedaan om het probleem duidelijk te maken.

Het is dus zaak dat het gewogen gemiddelde herschreven wordt met de kennis dat een test van 50% niets zegt en 51% haast niets zegt en 99% bijna alles zegt. Maar hoe?

[KabouterSuper]

Kijk nog eens even naar mijn opmerking:

KabouterSuper schreef op maandag 09 maart 2009 @ 17:01:
Nog een leuk criterium om te testen of je kans zuiver bepaald wordt: Een test met zekerheid 100%. Hieruit zou moeten volgen dat de kans P(bit_1)=100% of 0%. (Pete's methode zal dat niet geven)

Je kunt wegen tot je een ons weegt, maar met Pete's aanpak gaat het je niet lukken. De oplossing die ik gisteren heb uitgewerkt werkt wel goed in dit soort situaties, omdat de normale verdeling op een natuurlijke manier de betrouwbaarheid van de test meeneemt.

[ Voor 8% gewijzigd door KabouterSuper op 10-03-2009 12:34 ]

[Zoijar]

Wat is die betrouwbaarheid eigenlijk? De kans dat je antwoord klopt? De kans dat de test een zinnige uitkomst heeft? Als een test met betrouwbaarheid 10% zegt dat het een 1 is, wat betekent dat? Is dat dat 9 van de 10 tests geen zinnige uitkomst hebben, en 1 op de 10 geeft het correcte antwoord? Kan een onzinnige uitkomst alsnog het juiste antwoord zijn? Zijn de testen onafhankelijk? Iets te weinig info over het onderliggende kansmodel om er iets zinnigs over te zeggen. Een 50% betrouwbaarheid kan wel degelijk iets zeggen, maar het hangt af van je definities; als het met 50% betrouwbaarheid een 1 is, dan heb je 50% kans dat deze test het juiste antwoord geeft (op het domein van meerdere tests), nl. 1. Dat zegt niet dat er ook 50% kans is dat het een 0 is, het zegt alleen dat het in 50% van de test gevallen geen betrouwbaar antwoord is, en dan kan het in het echt ofwel een 0 ofwel een 1 zijn.

[DeoDupke]

Het is me niet helemaal duidelijk maar wat ik eruit opmaak is dat je een binaire beslissing moet maken aan de hand van een aantal features, klopt dat?

In dat geval zou je misschien eens kunnen kijken naar verschillende machine learning algoritmes

[Kaw]

KabouterSuper schreef op dinsdag 10 maart 2009 @ 12:33:
Kijk nog eens even naar mijn opmerking:

[...]


Je kunt wegen tot je een ons weegt, maar met Pete's aanpak gaat het je niet lukken. De oplossing die ik gisteren heb uitgewerkt werkt wel goed in dit soort situaties, omdat de normale verdeling op een natuurlijke manier de betrouwbaarheid van de test meeneemt.

Ik denk ook dat jouw opmerking ook in de goede richting is, maar ik weet zodanig weinig van kansrekening af dat ik dit niet kan uitwerken tot code. Je voorbeeld is een pijl in de goede richting, maar je draagt niet de oplossing aan. Dat je een richting aan geeft ben ik je dankbaar voor, net als voor iedereen die in dit topic reageert, maar voor mij is de missing link dan wel hoe ik het vervolgens moet invullen.

code:

            bool c;
            bool d;
            bool e;
            int s = 0;
            int n = 0;
            int k = 100000000;
            for (int i = 0; i < k; i++)
            {
                if(random.NextDouble() <= 0.5)
                    c = true;
                else
                    c = false;
                if (random.NextDouble() <= 0.51)
                    d = c;
                else
                    d = !c;

                if (random.NextDouble() <= 0.99)
                    e = c;
                else
                    e = !c;

                if (d == e)
                {
                    n++;
                    if (c == e)
                        s++;
                }
            }
            double p = (double)s / (double)n;

Dit is een eenvoudig experiment om vast te stellen wat de uitkomst is van de zekerheid die een test met 0.99 zekerheid en een test met 0.51 zekerheid oplevert, namelijk grofweg 0.99034. Het toont aan dat als beide tests een 1 opleveren, dat ik dan voor 0.99034 zeker weet dat het een 1 is. Als (d != e), dan verlaagt dat de zekerheid naar ongeveer 0.98962. Overeenkomstig aan wat ik had verwacht.

Maar de achterliggende formule om tot dit resultaat te komen? Dat is wat ik zoek...

[Kaw]

DeoDupke schreef op dinsdag 10 maart 2009 @ 13:11:
Het is me niet helemaal duidelijk maar wat ik eruit opmaak is dat je een binaire beslissing moet maken aan de hand van een aantal features, klopt dat?

In dat geval zou je misschien eens kunnen kijken naar verschillende machine learning algoritmes

Volgens mij is de data niet echt fuzzy en is de techniek die gezocht wordt relatief eenvoudig, waardoor een vorm van machine learning zoals een neuraal netwerk teveel van het goede is en waarvan het resultaat afhangt van de learning, iets wat niet echt geweldig is wanneer je met datacompressie bezig bent. Ik bedoel: je wil ook wel iets meer dan 1kb per minuut comprimeren.

[Kaw]

Zoijar schreef op dinsdag 10 maart 2009 @ 13:01:
Wat is die betrouwbaarheid eigenlijk? De kans dat je antwoord klopt? De kans dat de test een zinnige uitkomst heeft? Als een test met betrouwbaarheid 10% zegt dat het een 1 is, wat betekent dat? Is dat dat 9 van de 10 tests geen zinnige uitkomst hebben, en 1 op de 10 geeft het correcte antwoord? Kan een onzinnige uitkomst alsnog het juiste antwoord zijn? Zijn de testen onafhankelijk? Iets te weinig info over het onderliggende kansmodel om er iets zinnigs over te zeggen. Een 50% betrouwbaarheid kan wel degelijk iets zeggen, maar het hangt af van je definities; als het met 50% betrouwbaarheid een 1 is, dan heb je 50% kans dat deze test het juiste antwoord geeft (op het domein van meerdere tests), nl. 1. Dat zegt niet dat er ook 50% kans is dat het een 0 is, het zegt alleen dat het in 50% van de test gevallen geen betrouwbaar antwoord is, en dan kan het in het echt ofwel een 0 ofwel een 1 zijn.

Zoals ik al beschreven heb wordt de betrouwbaarheid van een test gedefinieerd door het aantal successen gedeeld door het aantal pogingen. Een test kan 0 of 1 opleveren en van een test weet ik dus dat van de afgelopen keren hij het bijv. in 70% van de gevallen goed had. Dat wat je schrijft is vast heel filosofisch, maar uit mijn testen blijkt dat de vastgestelde betrouwbaarheid van een bepaalde test voldoet en vrijwel gelijk is aan (de betrouwbaarheid van) de resultaten die dan vervolgens verwacht mogen worden.

[Pete]

Ok. Ik zat in het begin fout. Ik heb even de bayes benadering opgezocht, een netwerk gemaakt en tot deze formule gekomen:

Waar C de uiteindelijke waarde is en X de testen.

De waarde voor een test is de betrouwbaarheid indien 1, 1-betrouwbaarheid indien 0

Dus voor je voorbeeld:
0.99 * 0.51 * 0.5/ (0.01 * 0.49 * 0.5 + 0.99 * 0.51 * 0.5) = 0.9904


Indien je 2de test een 0 had gegeven:
0.99 * 0.49 * 0.5/ (0.01 * 0.51 * 0.5 + 0.99 * 0.49 * 0.5) = 0.9896

(Ik schaam me diep dat ik, met mijn opleiding, je eerst van de wal in de sloot heb geholpen)

[Kaw]

Pete schreef op dinsdag 10 maart 2009 @ 14:12:
Dus voor je voorbeeld:
0.99 * 0.51 * 0.5/ (0.01 * 0.49 * 0.5 + 0.99 * 0.51 * 0.5) = 0.9904


Indien je 2de test een 0 had gegeven:
0.99 * 0.49 * 0.5/ (0.01 * 0.51 * 0.5 + 0.99 * 0.49 * 0.5) = 0.9896

Super!

FF ter controle of ik het snap...
Stel je hebt nog een test er bij van 0.75, dan krijg je de volgende?:
0.99 * 0.51 * 0.75 * 0.5 / (0.01 * 0.49 * 0.25 * 0.5 + 0.99 * 0.51 * 0.75 * 0.5) = p(1)

[Pete]

Kaw schreef op dinsdag 10 maart 2009 @ 14:38:
[...]

Super!

FF ter controle of ik het snap...
Stel je hebt nog een test er bij van 0.75, dan krijg je de volgende?:
0.99 * 0.51 * 0.75 * 0.5 / (0.01 * 0.49 * 0.25 * 0.5 + 0.99 * 0.51 * 0.75 * 0.5) = p(1)

Ja, idd. (als die test ook 1 als uitvoer geeft)

[KabouterSuper]

Hier mijn berekeningen:

Crux is het bepalen van een equivalente normaal verdeelde stochast met variantie 1. Voorbeeld is een uitkomst van 1 met 70% betrouwbaarheid. Omdat P(X1>=0.5)=70% geldt als het gemiddelde van X1 gelijk is aan 1.024400513, noteren we dit gemiddelde. Zo krijg je voor elke test een gemiddelde:

uitkomst betrouwbaarheid Gemiddelde van equivalente normaal verdeelde stochast
1 70.000% 1.024400513
0 60.000% 0.246652897
0 55.000% 0.374338653
1 55.000% 0.625661347

Het gemiddelde is in excel taal overigens 0.5+SIGN(A2-0.5)*NORMSINV(B2) als A2 je uitkomst is, en B2 je betrouwbaarheid.

Voor het gemiddelde van de bovenstaande stochasten kijk je nu naar de geschatte uitkomst (0 als gemiddelde <=0.5 en 1 anders). Voor de kans gebruik je dat de variantie nog steeds 1 is. Voor bovenstaande uitkomsten levert dit 52.7% betrouwbaarheid op. In Excel taal is dit C10-SIGN(C10-0.5)*NORMDIST(0.5,AVERAGE(D2:D5),1,TRUE), waarbij C10 je geschatte uitkomst is, en D2..D5 de gemiddelden per test.

Ik kan je de Excel sheet mailen.

[Pete]

KabouterSuper schreef op dinsdag 10 maart 2009 @ 14:51:
Hier mijn berekeningen:

Crux is het bepalen van een equivalente normaal verdeelde stochast met variantie 1. Voorbeeld is een uitkomst van 1 met 70% betrouwbaarheid. Omdat P(X1>=0.5)=70% geldt als het gemiddelde van X1 gelijk is aan 1.024400513, noteren we dit gemiddelde. Zo krijg je voor elke test een gemiddelde:

Waarom haal je hier een normaal verdeelde stochast bij terwijl het enkel een mixture van discrete variabelen zijn?

Wat is jouw percentage op de testcase:
1 90
0 55
1 60

Voor de testcase in jouw post mijn antwoord is 60.9 procent waarschijnlijk 1

[ Voor 11% gewijzigd door Pete op 10-03-2009 14:58 ]

[KabouterSuper]

Ik gooi het even door de excelsheet....done:

0.68073167

En om antwoord te geven waarom ik normale verdelingen erbij haal: In het begin was het helemaal niet duidelijk dat het ging om discrete variabelen...het ging erom dat je een kans wilde bepalen aan de hand van een aantal testuitslagen met elk een verschillende betrouwbaarheid. Er stond nergens bij dat de betrouwbaarheid zelf een schatting was.

[ Voor 94% gewijzigd door KabouterSuper op 10-03-2009 15:01 ]

[Pete]

Mijn antwoord is 91.7%.

Het is logisch dat het hoger is dan 90% aangezien de 60% test zwaarder weegt dan de 55%.

[KabouterSuper]

Oeps.....foutje in mijn formules, je redenering is inderdaad wel logisch. Ik had de variantie van het gemiddelde gelijk aan 1 verondersteld, maar dit is natuurlijk 1/#waarnemingen. Hiermee worden de schattingen:
60.68% voor mijn eigen testsetje (Pete's methode geeft 60.9%)
en
92.06% voor Pete's testsetje (Pete's methode geeft 91.7%)

Dus beide methoden zijn vrijwel gelijk.

[ Voor 15% gewijzigd door KabouterSuper op 10-03-2009 19:36 ]