Talk:Visit Count Stats

Credits - Visit Count Stats Old wiki page: VisitCountStats Original author(s): PEZ

Credits - Visit Count Stats Old wiki page: VisitCountStats/LimitFileSize Original author(s): PEZ

Credits - Visit Count Stats Old wiki page: VisitCountStats/Dynamic Original author(s): PEZ

VertiLeach/Code also shows how to store and restore these visit counts to and from files on disk. To add file growth limits to this (with some decay) you can try /LimitFileSize. One way to avoid much of the need for curve smoothing and/or Kernel Density Estimation calculations and always have ready-to-use stats is to use the technique depicted in /Dynamic.

Don't confuse visit counts and GuessFactorTargeting. They are not the same. Marshmallow uses visit counts but has never, and will never, use guess factors. Visit counts are just as applicable to LaserTargeting or EscapeAreaTargeting for instance. -- PEZ

I suppose you're trying to make the distinction between knowing where the enemy was vs. where you could have shot to hit the enemy. However, I disagree to some extent and consider FloodMini to be very much a GuessFactorTargeting bot. In other words, I think of VisitCountStats as merely an implementation decision in my GuessFactor guns (while I agree that this is a general term - it could apply as well to non-guess-factor guns). I consider the definition of GuessFactorTargeting to basically be anything where you attempt to shoot at the mode of shot directions you observe to work against an opponent. -- Kawigi

I don't see what you mean really. Of course FloodMini is a GuessFactorTargeting bot. And so are all the bots I have created in the spirit of FloodMini visit counts. I just mean visit counts and guess factors are different entities. One being a targeting strategy (guess factors) and one being an implementation detail (visit counts). -- PEZ

So in essence, the only difference between guessfactor bins and visit counts are how they are used. ;) -- Chase-san

Well, they are just different things. You could have a GuessFactor gun without VisitCountStats, as in the DynamicClustering gun of Lukious (there's a terminology discussion on that page, too...); you could also have a VisitCountStats gun without GuessFactors, like using bearing offsets instead. The majority of GuessFactor guns, like the one in GFTargetingBot or the GuessFactorTargeting/Tutorial, are using VisitCountStats, but they're different things for sure. -- Voidious

I'm not sure I understand your use of terms. How does a DynamicClustering gun count as a GuessFactor gun? And how would you make a VisitCountStats gun that didn't use GuessFactors? --David Alves

Lukious keeps a log of scans, each containing raw attribute data (unsegmented) and the GuessFactor that hit from the wave sent for that scan. To aim, it finds the closest N scans using a distancing function on those attributes - this is the dynamically generated cluster. (As opposed to like k-means clustering, which would find k centroids in all the data, and fit the current scan to the correct centroid.) Then it looks through these N scans for the scan with the highest kernel density in relation to all the other scans, and aims at the GuessFactor of that scan. (The key difference between this and the original TronsGun description is GuessFactors instead of path retracing.)

A VisitCountStats gun that doesn't use GuessFactors doesn't really make any sense to me, but that doesn't mean you can't do it. You could just use raw bearing offset instead of GuessFactors to aim at in a segmented, statistical gun.

-- Voidious

So Lukious stores the solution angle... I wouldn't call that GuessFactor targeting. To me GuessFactor targeting means that you store an array of numbers representing the success rate of different angles. In effect, you're "segmenting" the range of possible angles into little bins and storing the success rate for each bin. To me the difference between VisitCountStats and GuessFactors is that VisitCountStats means you're counting the actual number of times that the enemy has visited a particular segment or bin, whereas GuessFactor targeting is more general, you're storing a "success rate" for each bin, which could either be a visit count, or a rolling average. Another difference is that VisitCountStats can refer to either a bin or a segment, whereas GuessFactorTargeting refers only to storing stats on different bins. --David Alves

Hmm, interesting. To me, a GuessFactor is a bearing offset with adjustment for enemy's initial direction and scaled to the bullet power's max escape angle. Lukious, in my mind, definitely stores a GuessFactor and aims at a GuessFactor. Though I could see how the "guess" in the original GuessFactor term could have been a result of splitting the escape range into X bins, something that really isn't present here. Seeing as I wasn't around when these terms were coined, I'd tend to defer to someone like you =)

I was going to add, too, that something like DisplacementTargeting strikes me as another idea that could be mixed with VisitCountStats without any GuessFactors.

-- Voidious

I've always thought of this the way David described it, but it's really just an issue of terminology. Maybe we should start a Terminology page where we agree on "official" definitions for things like this and put them there. It would make discussions more clear if we're all using the same definitions of terms. --wcsv

PEZ came up with the VisitCountStats term, so he should explain it better. For me it represents the classification of continuous data into bins, like Voidious said. A guess factor is an angle converted to a % of the max excape angle, so it can be used in a DC gun. I also don't understand fully how a VCS gun can work without GFs, maybe highly segmented on distance it will work... -- ABC

How about "Visit counts is a way to keep track of statistics. Typically this is implemented with an array or a List where each bucket contains a count on how many times it has been visited." =) I actually don't know of a better way to describe it. VCS is very possible without GFs, but GFs are so cool so there's little point in avoiding them. It doesn't change the fact that GFs aren't VCS though. I think maybe it's GFs that need a better explanation. Let me some short descriptions:

• GF: A way to represent a possible fire angle, utilizing the lateral direction of the target at the time of fire.
• VCS: A strategy for remembering good and bad fireangles, dividing the full fire angle "space" into X number of count bins and keep updating these counts as data is collected.

OK. Maybe both can be explained better, but I do hope it should be clear that they are not the same. Let me add:

• Waves: A strategy for collecting hit/miss data on real or imaginary bullets. Keep track of the distance traveled by the bullet and update stats when this distance equals "fire_location.distance(current_target_location)".

-- PEZ

Waves are one way of collecting data. Guess factors are one way of interpreting the data. Segmentation is one way of organizing the data. Visit counts are one way of storing the data.
An alternative to waves are virtual bullets. An alternative to guess factors are raw bearing deltas. An alternative to segmentation may be a neural network or dynamic clustering. An alternative to visit counts is a rolling average.
All the moving parts make up a gun, Guess-Factor or otherwise. My first simple guns used virtual bullets, interpreted a simple success or fail for the virtual or real bullets, segmented the success rates on bullet flight time, and used bins to store hits vs. misses. Tracking multiple targeting options in this way gave me a virtual gun array. The main difference between it and a guess-factor gun is that rather producing a bearing to fire at directly, I'd retrieve a targeting system to use, which would produce a bearing to fire at. -- Martin

Interpolation/Antialiasing

This is what I wonder, has anyone done Interpolation/Antialiasing (interpolation for reading, antialiasing for writing) between adjacent VCS buffers in the segmentation space before? If not, then my semi-secret bot will be the first to do this. I suspect this could notably increase both accuracy and learning rate... :) --Rednaxela 16:04, 3 December 2008 (UTC)

Never done interpolation, but I've tried the "antialiasing" thing before. But it was long before I knew what I was doing, and I thought that was what "BinSmoothing" was. My implementation was horribly slow and lame. Martin Alan Pedersen has done this (the "antialiasing") a bit, too, though I don't know much about the details or success he had. I wonder how far this would be from DynamicClustering in its results. Good luck in any case. :-) --Voidious 16:25, 3 December 2008 (UTC)

Thanks. I too have wondered how far this would be from DynamicClustering... My hope is that it will provide some of the benefits of it while being fast enough to run a large number of segmentation combinations in parallel... (hint: while nothing new to use many buffers at once, it will be key to parts of my new gun that will for sure be new) :-) --Rednaxela 16:37, 3 December 2008 (UTC)

Another way to run many segmentation combinations (in fact, all of them) at once is detailed at Segmentation/Autoselected Segmentation. -- Synapse 21:00, 29 September 2009 (UTC)

... Now I've got the itch to try that out with SaphireEdge. I'm not sure about the usage of crest factor as mentioned there though. It seems to me it would basis heavily in favor of high-noise segment combinations. What I think would be needed would be to first calculate the expected typicl crest factor for a certain number of random data points, and divide by that. --Rednaxela 22:08, 29 September 2009 (UTC)

The crest factor picks segmentations with the most pointiness - with the best possible segmentation containing a single bin at 100% and the rest at zero. It prefers a single tall point to lots of points, and it produces a value of 1 (the minimum) for a completely flat segment. -- Synapse 01:22, 30 September 2009 (UTC)

I know that's what the crest factor picks. What you need to remember, is that when the data is noisier (fewer data points), it's more likely to have more random peaks, and thus a higher crest factor. That's why I say that the theoretical average crest factor of a set of bins with x random insertions, must be used as a baseline to compensate for that bias. --Rednaxela 02:26, 30 September 2009 (UTC)

I get it now. Thanks for explaining! -- Synapse 04:44, 30 September 2009 (UTC)

I think I get a similar effect in DrussGT by combining sets of stats with slices that are more course or fine, or overlapping. I wonder which way is faster... adding lots of buffers together or antialiasing just once when you store the info. I originally did this to try to get values that would be closer to DynamicClustering, while somehow keeping that VCS magic. --Skilgannon 17:47, 3 December 2008 (UTC)

I suspect it would be much faster to write to the surrounding segmentations as you record a hit, rather than combining them whenever you need to check for danger. -- Synapse 21:00, 29 September 2009 (UTC)

Now that we have two bots/people kicking butt with this, is it time for it to get its own page and a more formal description? --Voidious 18:19, 29 September 2009 (UTC)