On 8/21/07,
Jim Segrave <address@hidden> wrote:On Mon 20 Aug 2007 (17:28 -0400), Roy A. Crabtree wrote:
> I will have to agree with the idea, but disagree with the line of reasoning:
>
> gnubg cannot be assuming that the strengths are equivalent.
gnubg simply assumes its opponent will play optimally at all
times.
BUT the NNP engine inside the DB does NOT. (Necessarily, So I assert).
To the extent that the pattern of play in the presence of a particular PRNG/"TRNG"
CAn be improved upon in terms of chance of winning WITHIN a static net of plays
(one given roll gives one given outcome always); it is simply the case that the NNP DB
(firing sensitivities) emfolds these within a structure that is "masked" by the static nature of
the DB.
It would be spectacularly difficult to design an NNP that would NOT learn such things this way.
That is the nature of the responsiveness of a neural network. According to accepted theory.
If the cube play does not use the inferential DB to improve its play:
you should.
Dynamic behavior/appearance and actuality
CAN be done with a static net, simply by having the equivalence classes
within the DB match the masking implied by all static considerations.
BTW, simply asserting an abnegation on the basis of your own knowledge of
the nature of the engine does NOT imply a proof has been provided that
removes the consideration that the combination (engine, DB)
COULD or DOES provide this behavior.
And, in fact, with an NNP program:
you would be hard pressed to delineate that it COULD learn to play at ALL
without such a possibility being implicit.
The response network would have to be durned stoopid not to learn such behavior
over millions of games played
for this to be the case.
Because: it would improve the win rate.
But: if you HAVE one (a proof), I would love to see it.
Note:
Optimal play is the play that gnubg would make in the
opponent's place - gnubg has no concept of its ever being less than
THAT is NOT what would be defined as _optimal_ play in any BG discussion.
I am not criticizing this as a defined term: it is inherently extremely useful
Just noting: in subsequent discussion:
the term as used hereinafter BY GNUBG EXPERTS "optimal play"
in NOT necessarily 'optimal play' (in BackGammon)
{under player considerations}[under roll considerations]
({[within the scope as human players have OR CAN learn the game]})
And THAT is what I am _asserting_ is (part of) what human players are picking up on.
Nota bene: I have NOT read through the code or design of the engine OR DB as yet. Time pressure.
perfect in its decisions. If it "thought" a particular play was not
the best one, then it would not make it, hence any play different than
HOWEVER: it would "learn" that the "best" one would be offset
by the style of the responsiveness of the play against it;
unless you wish to imply that:
NO human played game input EVER resulted in achange in its play:
that is to say:
ALL DBs ever found for ALL PRNG/TRNG/roll.sequences ever used to train them
ever made ANY position play differently than ANY learning of gnubg with only
machine generated play/game/match sequences.
Which I doubt you would attempt to say.
thus, de facto: you admit that the game DOES respond to
LESS than optimal play (human play) to IMPROVE its WIN rate.
gnubg's choice is, in gnubg's view, a mistake.
Actually, only under the assumption of default tunings, as there is an option
for the game to pick the Nth "best" (in its OHO) move. (presumption noted as
warranted for the purposes of this discussion: unless I noted such a specific tuning,
it would be directly implied by game defaults).
But the penultimate paragraph addresses my main point succinctly.
> i) If gnubg assume the match is (it, it) that gives matched rates and 60%
> wins
> ii) if gnubg assumes it is (it, you) that gives UNmatched rates and maximal
> verge of winning (80/99%)
>
> iii) But I do not think that it would assume that it is playing (you, you),
> as I do not think THAT pairing would
> gives wins in the 80-99% region for severely LESS than optimal players.
>
> Either:
>
> a) gnubg is weighting the cube for condition and incorrectly assigning the
> figure, or
Neural nets are not infallible and gnubg will often obtain different
results when rolling out a play than the NN evaluation gives.
> b) it is weighting for condition ii (or others) and recommending the
> preferential cube so as to up it's match win rate
>
> which I do not think, as it is to obvious an error to miss
Nope
Agreed, I made a typo ("as it is too obvious").
However, I note that the argument I gave above STILL does NOT say this about the pair of (engine, DB).
> OR:
>
> c) the NNP engine has determined against millions of plays of games that:
>
> i) each differing (or ther sum acumulated similar characteristic) NNP
> PRNG
> has a specific set of characterisitics IT can detect
Nope - gnubg makes the assumption that the dice are random and that
future rolls will not be biased.
BUT: the DB does NOT imply this (so I assert): only the engine.
> ii) that humans can NOT detect (**as easily: Ramanujans for math AND
> gammon exist**)
Nope - gnubg makes no assumption about the other player's ability
beyond choosing a play which is best against a player equally strong
as gnubg itself.
BUT again, you have to look at the variant part of the program:
the response net and learning effect in the DB against the neural net.
Again, to reiterate, the mere fact that YOU cannot see it from the _program_ coding,
in NO way, in ANY sense, proofs or proves that the OVERALL effect of the program AND NNP net DB
(sensitivities for the firings) does NOT have this type of property:
inherent to more than one level.
merely that the static 'folding' of such a tree of catastrophe manifolds into a much, much
SMALLER
eigenstate space
is more difficult to assess as to IF< WHERE and WHEN, and
HOW MUCH
of that original full span tree of
EFFECTS and RESULTS (decision to use a particular play in a game situation)
still remains.
> iii) that gives it the ability to use a static tree of equivalence
> classes
> iv) buried in the NNP DB IMplicitly (not pulled out; as such:
I think this is not an effective way of looking at the neural net. A
The game does not care what you think.
it cares about effects and results.
That is what it was trained to do.
neural net generates a very complex transfer function of the input
variables to produce a set of outputs which should represent the
It is not about what it SHOULD do. It is about what it DOES do.
probabilities of the outcomes of a game. Note that the inputs to the
neural net do not include the score, match length, cube ownership or
value, history of the match or session or anything else other than the
position of the chequers. It also does not include a current roll of
Which does NOT imply that the state space does NOT _encode_ them in the DB.
Or: ANY effective eigenstate co-equivalent to:
ANY EFFECTIVE (increased probability of game winning) PART OF THEM.
the dice - in order to evaluate the probable outcomes after the dice
are rolled, gnubg does a NN evaluation or the tersulting position of
each legal move it is evaluating. The closest you get to equivalence
classes would be gnubg's choosing which neural net to use - there is
You are inverting what I said.
The equivalence classes I drew are:
a) The ones implicit in backgammon
b) the ones implicit in a roll of the dice structure
c) the ones that result from folding a dynamic tree of spaces into a limited static one
WITH AN ENTIRELY DIFFERENT MAP (since the states to don't have to correspond in any
linear sense (or in any mappable sense at all: it can be a static snapshot of a dyanmic
chaotic equation set).
... here;s the important part:
d) OR ANY EIGENSTATE AT ALL that captures ANY salient PART of that;
(that is to say: it _learns_ something)
e) OR ANY CO_HOMOLOGOUSLY OR HOMOMORPHOUSLY EQUIVALENT STRUCTURE
or homeostatic eigenstate (sub/super)set,
f) OR ANYTHING ELSE OPERATIONALLY EQUIVALENT
that is to say: the game does not care what YOUR math says, it does what it does.
NOT just and only what you understand, think, or want it to do.
more than one available as it was found that a single neural net for
all position types from racing to crashed boards was not accurate
enough.
gnubg does NOT have to HAVE a data structure that HAS the equivalence classes in it
to have eigenstate that captures the resulting PLAY implicit from USING one.
Any more than it has to have the same analysis pattern
a human grandmaster uses to find an optimal move sequence.
And: it DOES do so.
Just better than maybe it's creators want to think it does.
> the game, the engine, the programmers are ALL honest BUT:
>
> gnubg succesfully "cheats" by having advanced knowledge of the PRNG
>
> by means of its millions of plays of experience no human will
> have
See above - the only assumption made is that the dice rolls will be
fair and random.
I hear your statemnent: But the fact that the _engine_ rpresumes this
IN NO WAY
means that the OPERATIONALLY EQUIVALENT meaning has NOT crept into the DB
making the pair (engine, DB instance) operationally
EQUIVALENT
to such a state of affairs.
And: you would expect a learning engine to DO this.
Because: it would INCREASE THE WIN RATE.
Do you have ANY measure that PREDICTS for gnubg WHAT IT'S WIN RATE SHOULD BE
on the basis of the number of PLAYS it has
that in turn either does or could be made to distinguish
BETWEEN THE RATE OF WINNING
based on
HWOW MUCH (0-100%) of the _information_ __IN__ a play sequence is picked up
subsetting and structurally cleaving between these categorical distinctions
in the implied knowledge set
of a particular set of plays fed to the DB?
I doubt it.
Without that, you would be hard pressed to EXCLUDE these
as not existing in the end result:
you have to explain ALL of the winning implied by the learning
AND
proof/prove that the winning implied by the learning sets YOU choose
to _describe_ "how" it thinks actually IS
__all__ and __only___ all of what you say it is.
Otherwise: the thesis I am asserting has NOT been proofed.
More than that: you have to demonstrate that the thesis set I am asserting is NOT operationally
co-equivalent across any part of the game playing space to your thesis set.
Believe me, this is not easy to do.
Which is why I will leave these assertions as assertions.
> to successfully predict AGAINST a human player
>
> based on its first 2-4 responses from the player
OR MORE. I see at least a 3 layer depth in triples;
and with arithmetic going to N significant digits, it could easily be o( log(3, 10^N) ) levels.
>
> as to which equivalence class it should go
gnubg does not choose plays based on the history of the game. You can
the engine does not. BUT you have failed to address whether the eigenstate
in the DB encapsulates any of the operational characteristics of that (totally different) model.
Until then, you are niot addressing the actual results of an NNP in a context.
take some position in a game and ask gnubg to analyse it and recommend
the best move. If you then ask the computer to make a move, that's the
move it will make. If you then go to another computer with a copy of
gnubg and set up the same position using the edit function (so there's
no history of moves made available on this computer) and repeat the
analysis, you will get the same results.
Which does NOT change what I just said. Nor address it, nor defeat it.
You have to demonstrate that NONE of the eigenstate is carried into the result
operational space, which you have not done.
> hidden (because of the static nature to the NNP network responses ALWAYS
> being the same
Correct, the NN is static.
BUT: a dynamic response set CAN be partially carried into a static space.
> to the same position in the same game in the all games in the same match
> (as opposed to being dynamically _differentiated_ based on your previous
> in-that-game-play)
>
> but NONETHELESS in an effectively different equivalence class
I can not follow what you are saying here. Gnubg doesn't have
equivalence classes in the sense I'm guessing you are using.
BUT the _operational_results_ from the pair (engine, DB instance)
CAN have the co-equivalent response states: some to all.
> that WILL respond to the nature of your PLAY on DIFFERENT POSITIONS
> based on its knowledge of WHAT ROLLS WILL OCCUR FROM THE PRNG.
Gnubg does not have any foreknowledge of the upcoming dice rolls.
BUT: the DB _does_. From the plays used to "learn".
> ALL of this calculated from the plays it HAS had and NOT because the CODE
> of the engine is dishonest.
Only in the sense that the neural net has been trained by having gnubg
To restate what I said: the code is honest, but the DB/engine pair fool YOU
into thinking it has no learning about the PRNG/"TRNG" sequences.
evaluate huge numbers of positions and then played out that
position. If the played-out results don't match the initial
evaluation, the weightings in the neural net are adjusted to make the
evaluation closer to the actual result. There is a classic paper on
training neural nets which explains this - warning, not for the
mathematically faint of heart:
http://researchweb.watson.ibm.com/massive/tdl.html
> You can see it most easily by watching the difference in the win rations
> form a PRNG to random.org.
If you use the Mersenne twister PNRG in gnubg you will need to play a
lot of games before the results show any statistically significant
difference from using dice rolls from random.org. By a lot of games, I
mean a significant portion of the lifetime of the universe.
Since you have only used an English language phrase to make an _assertion_
it is not in fact possible to discuss this on any mathematical basis.
because you have not defined your terms, metrics, and reliability metrics in any sense
rigorously enough
to be able to do so.
And this is where I am asserting that the GAME _does- "Fool" you:
IT knows MORE about ITself than YOU do.
> And you can tell that random.org IS NOT FULLY RANDOM (look at the bit
> slicing algorithm that cuts out
> long 1/0 sequences), in that the win rate is about 1/3 of the differential
> your human EXPECTATION
I think you'll have your work cut out for you demonstrating any
statistical weakness in the numbers from random.org
Chuckle. But not from an eigenstatic/hysteretic point of view.
You need to look at the actual papers on
random.org itself and note:
the full span of tests RECOMMENDED has NEVER been carried out.
For mere STATISTICAL fairness.
Not even the ones that were a DECADE OLD at the time
random.org came up.
((This is NOT an implied criticism of the people of
random.org;
it IS a DIRECTLY STATED _critique_ of the inherent danger of using
authoritative opinion
in the
absence of actual mathematical results done
where
direct measurement can be done.
Example:
To reiterate: if in fact atmospheric data were RANDOM (define this precisely;
U(0,1) is a start, not a final result), then:
why would you need to REMOVE extended all 0/1 sequences FROM it?
Therefore: it is NOT random and FOLDING OUT such sequences MAKES IT LESS SO
and a pair (engine, NNP DB instance) CAN LEARN FROM THIS whether humans ever do
BUT: it DOES make it MORE difficul to do what?
MEASURE such lack of randomness using the tools THAT WERE CHOSEN.
WHAT PROOF have you that such measure ESTABLISH such a state (randomness)?
Only that the measures chosen have failed to measure it as being NOT random.
WHAT in all this proves in ANY sense that an NNP will NOT pick up characteristics
(or any operationally equivalent eigenstate or hysteretic property OR EQUIVALENCE)
form ANY specifc characteristic that IS presented in such a (hidden, or missed) lack of randomness?
How about a hidden or missed set of characteristics IN THE ORIGINAL DEFINITIONS
that mathematicians have been blind to for decades?
(Or have we all forgotten what Goedel did to R&W and Hilbert? [[Also _interpreted_ wrong, BTW]])
> as an expert gammon player, though perhaps not world class
>
> will se or feel as what SHOULD have been the case as to cube pushes.
>
> ALL of this hidden within the expected values of the relative field strenths
> of the ratings as given
> with charactersitics (AKA "tells") that gnubg can see
I am unable to understand what the above paragraph means.
Actually, more saliently, possibly: at this moment, that is what you are saying.
And possibly at that moment you did not.
But NOT that you are unable to. necessarily: though that also may in fact be the case.
The key point is that a rating is an eigenstate of a computation.
Which has its own structures AS A GAME.
A "tell" is a state of affairs or occurrence that relates to a salient effect or occurrence in
the scenario that in turn can be used to predict or alter an outcome.
PLEASE NOTE CAREFULLY:
you do NOT need to PREDICT an outcome
in order to be able to successfully ALTER it.
> and that a world class player can see gnubg playing, AND AVOID the
> unstable areas
> that a naive player favoring either fair dice or human rolled dice
>
> these are NOT the same
>
> and hence, EXPECTING this, will play _towards_, and LOSE ground,
>
> becuse:
>
> the PRNG and TRNG involved are not those sequences.
>
> And the NNP will ALSO have picked up characteristics in human rolled dice
>
> the SAME WAY
>
> that most naive players will not see, and will also pick characteristics
>
> in HUMAN PLAY against FAIR dice as contraposed the rules of backgammon
>
> in the same manner:
>
> at a sensitivity level (incremental contextual advantages across 4-8
> moves)
>
> that a world class player aint' gonna tell nobody he/she already sees.
>
> And uses, to win.
>
> of couse, that is only my ownhumble opinion
>
> of this rather brilliant piece of SW gnubg:
>
> it is fooling its own creators quite well...
I note no comment past the above point of lack of understanding.
here is another kvetch that may illumine the dark space of lack of congrunet communication here:
How many eigenstates does the NNP in the code have?
How many nodes encode these spaces?
How may eigenstates CAN the DB have in total?
How many are present in any one particular eigenstate (instance)?
See how recursive this gets?
How many when reduced to an information theoretic MINIMAL CANONICAL ENCODING?
How many cleaves are possible against the clash of these two sides?
This gives a rough measure of how many equivalence _states_ are possible
((Second level kvetch: HOW MUCH of any one particular state is carried in the other state
on the other side? {{It gets really hairy to make valid assertions and PROVE them here))
How many equivalence _classes_ can be formed by
ALL POSSIBLE PATHS through a backgammon game
ployed (potentially played/playable) against such a complex eigencleave?
Can you form a metric to MEASURE these against English statements?
(Such as the ones I asserted, or you denoted, above)
How much information state is present against such a mapping?
If a game has a 3rd or 4th level sensitivity, how far out of STRICTLY 50/50 does THAT clash have to for the game to gain useful information on the way to increasing its likelihood of winning of strictly true "random" (pick your definition carefully here) play?
And is this THE SAME as what human players heretoforenow have encountered?
In all contexts? In all subsets of play?
If not, then you are hearing/reading human players picking up ("learning") parts of gnubg's
ACTUAL LEARNING
that _you_ are effectively MISSING.
_I_ (and other users) are asserting this is so.
Does this make sense (not that you acknowledge it as being true ((thesis justified)) or a correct or compleat model.
Just: do you follow it?
--
Jim Segrave
address@hidden