idea: do a match and after get a "sensitivity" that maximazes your accuracy.
#31
still clearing it up ;) :
yaw(t) - yaw(t-1) is my dphi
k1/k2 is my c
but i am not sure that t + v, i didn't see that + in code in afternoon, in this computer i haven't sources, so tomorrow

next i found interesting article about it:
http://www.overclock.net/mice/173255-cs-...guide.html

if we will be sure function, we can use next methods for fun :)


Thanks given by:
#32
Alien the method described in that article is already implemented in AC under /findsens command (which i implemented and i will try to make it get replaced with this one if it turns out to be working like i think it is) that method has got one major flaw, it relies on the assumption that you can accurately pick the correct range everytime which is not realistic
edit---------
btw i finished the complete integration into AC further simplifying the code (and obviously removing the external data analizer) and i removed the old /findsens and replaced it with the new method now the training works like this:
first choose a sensitivity that you are comfortable with, then
type /findsens
play with an auto weapon till the optimizer decides it has captured enough samples
and then you get your perfected sensitivity :)
also i tried under different dpi settings and it works normally.
source code for this last version coming tomorrow :)
Thanks given by:
#33
Kirin, how about it changes your sensitivity during the match, so it gets different samples of different sensitivities.
Thanks given by:
#34
Oh yeah, that wouldn't screw up anyone. ;-)
Thanks given by:
#35
and R_R no.. the sensitivity can be estimated only if the "error" you produce is almost the same all over the training dataset that it captures

for example when i tried the algorithm using a sensitivity which was too high for me, my aim was very jittery (is that even a word?) and at the end of the training the optimizer wasnt able to find the optimun because the samples i produced had a low signal to noise ratio (if i can call it this way in this issue)

edit.
i have to thank Ronald_Reagan for helping me test, and for opening my eyes on how foolish it is to try to estimate sensitivity by confronting player aim and ideal aim, this can never work right.

so today i completely rewrote the whole thing into a accuracy pilotated bisection over a interval of sensitivities, which seems to always converge to the right value plus it works with any weapon
Occam's Razor "theorem" is once again right! XD

source code for this hopefully final release will be coming tomorrow :)

one pitfall for this method is that it requires more time from the user than the one before. but it's worth the result imo.
Thanks given by:
#36
(23 Aug 11, 06:23AM)Kirin Wrote: so today i completely rewrote the whole thing into a accuracy pilotated bisection over a interval of sensitivities

i use PC, is the above link the latest version of your original idea?
i want to be able to try out both.
Thanks given by:
#37
yes it is

hopefully last release:

http://www.megaupload.com/?d=AFBF1H4I

edit: this version is pre-final the last version i've been working on is for SVN and has been enhanced graphically and the code has been polished
Thanks given by:
#38
so at the risk of being called a grave digger xD i'm putting here the new approch that jumped to my mind when i was porting the code to the SVN version
------------------ old approch
for the previous version i talked about "accuracy pilotated bisection"
which at every iteration halves the interval discarding the sensitivity which had the worst accuracy
this in 6 steps led to reducing the length of the original interval to 1/64 of it
which is enough accurate for the purpose, the problem was that this approach required extensively trying steps*3 sensitivityes, in this case 18 different sensitivityes

it took approximately 30 minutes to finish all the procedure. plus the final value was subject to error introduced by progressively adapting to the tested sensitivityes

--------------------------- new approch

i best fit a parabola (y=x*x*c2+x*c1+c0) using Least Squares Minimization (for more info read note 1) to this 4 points:
X              Y
s*(1-h)      accuracy_0
s*(1-h/3)   accuracy_1
s*(1+h/3)   accuracy_2
s*(1+h)      accuracy_3
with:
s = starting sensitivity
h = 0.6
X = sensitivityes
Y = corresponding accuracyes

doing this i obtain a function that near to the given points approximates the player accuracy curve under different sensitivityes

then to get the actual final sensitivity value
i just have to find the parabola vertex (actually only the X coordinate of it) and make sure that c2 is less than 0 ( so that the vertex is the highest point and not the lowest)
if c2>0 no solution is given, in this case the convergence failed and most probably the reason is that you started from a value that was too far from your optimun

all this can be simplified to this:

denom=15.0*(acc[3]-acc[2]-acc[1]+acc[0])
vertex=S*(denom-(6.0*acc[3]+2.0*acc[2]-2.0*acc[1]-6.0*acc[0])*h)/denom
if(denom<0) sensitivity=vertex
(S = starting senstivity value)

the difference is that this new approch requires only trying 4 sensitivityes instead of 18 (~30 minutes compared to ~5 minutes)
it hasnt got the problem that the player progressively adapts to the testing sensitivityes (you only try 4 different values none of which is your original sensitivity)
plus it's many times more accurate since the (approximate) solution is achieved by finding the maximun of the approximated player accuracy curve

note 1:
The method of least squares is a standard approach to the approximate solution of overdetermined systems, i.e., sets of equations in which there are more equations than unknowns. "Least squares" means that the overall solution minimizes the sum of the squares of the errors made in solving every single equation. (Wikipedia)



Complete method derivation and source code here:

http://forum.cubers.net/thread-3814-post...l#pid69347
Thanks given by:
#39
Holy math, batman! That's confusing o_o
Thanks given by:
#40
Wow, great streamlining!
Thanks given by:
#41
for the math addicted here's the complete derivation :)

zip file with a HTML page (& related images) that show the complete derivation of the method
http://www.mediafire.com/?k0bfa08vo0bdeg9

PDF file (lower quality images)
http://www.mediafire.com/?ech47z7wg70mc78


and surprise surprise!! XD
SOURCE CODE:
removed (changed method, very similar, but the new always manages to output a result unlike the old one)
Thanks given by: