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)