I would like to identify divergences in a chain sampled by pymc3.
Each sample is associated with 1 group and 1 condition (coordinates in the trace).
For the purpose of this example, the following results are only considering 1 chain, and 1 condition (coordinate of the trace).
I am using Arviz.InferenceData to plot the trace of samples for a specific variable a_kg (where each line represents one group):
import arviz as az
# trace variable coming from pymc3.sample
azdata = az.from_pymc3(
trace=trace,
coords={'group': groups, 'condition': conditions},
dims={'a_kg': ['group', 'condition']}
)
azdata_sel = azdata.sel(chain=[0], condition='Control')
az.plot_trace(azdata_sel, var_names=['a_kg'], divergences='bottom');
The trace for each group is plotted below:
If I understood correctly, the divergences are shown on the bottom of the traces with a rug plot.
If this is correct, there is a divergence around draw 30.
Therefore, I get a slice of samples that has at least one divergence (in this case the slice containing sample 30) to explore this part of the trace in greater detail.
azdata_sel = azdata.sel(draw=slice(25, 35))
az.plot_trace(azdata_sel, var_names=['a_kg'], divergences='bottom')
I would like to identify why the chain diverges to understand better how this model works. However, when I look at the samples for variable a_kg, for each group, around draw 30, all values are restricted in a narrow, finite range:
array([[7.03689753e+01, 7.08419788e+01, 4.18270946e+01, 5.56815107e+01,
2.89069656e+01, 3.21847218e+01, 1.72809154e+01, 6.80358410e+00,
8.27741780e+00, 8.61561309e+00, 9.52030649e+00, 7.42601279e+00,
4.86924384e+00, 4.65123572e+00, 3.42272331e+00, 3.72094392e+00,
3.79496877e+00, 3.63692105e+00, 4.53843102e+00, 4.49938710e+00,
1.16647181e+00, 1.57530039e+00, 1.38785612e+00, 2.93999569e+00,
3.19698360e-01, 1.09373256e+00, 8.91772857e-01, 1.27258163e+00,
7.30115016e-01, 6.48975286e-01, 9.53344198e-01, 7.10095320e-01,
1.94587869e-01, 2.37110242e-01, 1.74995857e-02, 1.09717525e-01,
2.49860304e-01, 1.73485239e-01, 3.15215749e-01]])
Are divergences filtered out from draws during sampling? How would you proceed to diagnose what is going wrong in this case?
I think this doc has a lot of what you need to know: https://docs.pymc.io/notebooks/Diagnosing_biased_Inference_with_Divergences.html
But to summarise, you should know that understanding the divergences is a difficult problem in general and there isn't a silver bullet for it -- You'll have to try many (sometimes many many) things. Looking at the trace plots alone won't be enough. That being said, the document I linked you has a lot of good recommendations.
The general recommendation I can give is that you shouldn't focus on a specific sample that was divergent. That's meaningless. The thing that is diverging is not the sample but the trajectory. Use arviz.pair_plot and focus on where divergences concentrate (set divergences=True). Run much longer chains (more than 10k samples) so that you get a lot more divergences and can easily spot the pathological regions. Once you spot the pathological region, deciding what to do with it will depend on your specific model. Perhaps increasing the adaptation step, perhaps changing your priors, perhaps re-parametrizing your model.
Since you're talking about groups, I suspect you are using a hierarchical model. In which case I think the best approach would be to try an alternative parametrization. Look up for discussions about centred vs non-centred parametrizations in hierarchical models.
Best of luck in your divergence hunting! :)
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
We don’t allow questions seeking recommendations for books, tools, software libraries, and more. You can edit the question so it can be answered with facts and citations.
Closed 6 years ago.
Improve this question
Assume that every object (car, bike etc.) is connected to internet and giving me (Cloud) just its current position and its random id, which is changes every “T” sec. Since objects changes their id’s it becomes difficult to keep track of every object, especially in a busy area like city center. Can someone help me to design an attacker model, which can predict the trajectories of the objects. That means the Cloud has to predict the direction of the objects in next, say 15 min.
You can assume like 4 regions A,B,C,D (5-10km of radius each) which are close to each other. How can I (cloud) predict and say, so many number cars/bikes have moved from Region A to Region B or the objects which I have seen in Region A and after 15min in Region B are the same.
I have studied through Kalman filter. In my case I know only Random Id and positions. So First step could be guessing the velocity of each object from 2 consecutive position points, then forming velocity vector and position vector. Then applying position vector and velocity vector to Kalman filter. Somehow predicting the positions of objects in next 15 min. Ofcouse, need not be accurate atleast probable near by region.
Is kalman filter right choice? If so any python or c++ implementation that can help? Is there any other concept which can help in predicting the user locations? Is there any simulator that can help in simulating these networks? Can someone please help in designing this attacker model? Thanks a lot.
Edit1:
Main idea behind chaning the Object Id's is to protect the user(object location) privacy. My challenge is design an attacker model, where I can prove even though you(object) changed your Id's but I can still track you based on the speed, direction you are going. Let's say a car is going on a highway. It's id (assume 1234) at 12:00. At 12:15 it has changed its Id to 2345. since no one is going in the same direction,with that particular speed. The attacker can say Id:2345 and Id:1234 are from the same object. So This is a valid linkability. But if the same object is moving in busy area, like city center. I have many combinations like turns, parking lots(where many objects report same location with different Id's) it's difficult to say Id:2345 is from the same object Id:1234.
MainGoal:
If I can find the valid linkability of objects seen in Regions A (say at 12:00Pm) and in region B (say at 12:15) .That means I need to predict the Region B where the users(most of the objects) are trying to move. ofcouse some times It might be falsepositive. Since main goal is to protect user privacy, the false positive helps the users.
Is kalman filter right choice?
A Kalman filter won't help in cases where the future predicted position depends on whether the vehicle makes a turn. A Markov model may work better for those cases.
On a straight-away with no turns, a Kalman filter will do better. However, Kalman filters assume a gaussian (normal) distribution for noise (which likely is only true when the vehicle has no surrounding traffic).
An Unscented Kalman filter can help compensate for the non-guassian noise but it too has limits.
If so any python or c++ implementation that can help?
The pykalman package would be a good place to start.
A Kalman filter helps model the motion of a single object. The problem you have is that you don't know for certain which measurements (id,position) originate from which object, since they are allowed to change their ids. That makes this a tracking problem as well, where you'll need to estimate, for each object, the list of ids it has used in the past. The reason this matters is that it could take more than 15 minutes to get from Region A to Region B, and all the random-ids you receive from Region B don't match the ones you got from the object when it was in Region A.
There is a lot of work on these sorts of problems (see http://www.probabilistic-robotics.org/ for information).
I will attempt to describe a simple solution, but this is actually a deep topic with a lot of historical work. I'm describing a sort of variant of a Particle Filter here:
Keep a table of "Object" that will contain all historical information for the object (i.e., the car). This will store the historical list of (random-id, position) pairs you believe the object has used in reporting its position.
Each measurement you receive is (random-id, position, time). Decide which object it belongs to. How to decide? Well first, if the random-id exactly matches a previous one, and that id has been used for less than 15 minutes, then you can assign it exactly. Otherwise, you'll need to deal with cases where the random-id for the object has now changed. One obvious algorithm is to match it to object whose last measured position is closest. In general, your motion model (such as a Kalman filter) will determine how to do this correspondence assignment. Sometimes you'll have to decide that the measurement is in fact a new object that appeared out of nowhere, or from the edge of the map.
When you receive a measurement in Region B and have assigned it to an object, now check if any past measurement of that object was in Region A. That will tell if you have a situation of an object moving from Region A to Region B.
What I've described is essentially an online tracking algorithm with MAP estimation of correspondences, and a pluggable motion model. The algorithm will continuously maintain a list of "traces" of a each unique object.
SO I realise the question I am asking here is large and complex.
A potential solution to variences in sizes of
In all of my searching through statistical forums and posts I haven't come across a scientifically sound method of taking into account the type of data that I am encountering,
but I have thought up a (novel?) potential solutions to account perfectly (in my mind) for large and small datasets within the same model.
The proposed method involves using a genetic algorithm to alter two numbers defining a relationship between the size of the dataset making up an implied strike rate and the
percentage of the implied strike to be used, with the target of the model to maximise the homology of the number 1 in two columns of the following csv. (ultra simplified
but hopefully demonstrates the principle)
Example data
Date,PupilName,Unique class,Achieved rank,x,y,x/y,Average xy
12/12/2012,PupilName1,UniqueClass1,1,3000,9610,0.312174818,0.08527
12/12/2012,PupilName2,UniqueClass1,2,300,961,0.312174818,0.08527
12/12/2012,PupilName3,UniqueClass1,3,1,3,0.333333333,0.08527
13/12/2012,PupilName1,UniqueClass2,1,2,3,0.666666667,0.08527
13/12/2012,PupilName2,UniqueClass2,2,0,1,0,0.08527
13/12/2012,PupilName3,UniqueClass2,3,0,5,0,0.08527
13/12/2012,PupilName4,UniqueClass2,4,0,2,0,0.08527
13/12/2012,PupilName5,UniqueClass2,5,0,17,0,0.08527
14/12/2012,PupilName1,UniqueClass3,1,1,2,0.5,0.08527
14/12/2012,PupilName2,UniqueClass3,2,0,1,0,0.08527
14/12/2012,PupilName3,UniqueClass3,3,0,5,0,0.08527
14/12/2012,PupilName4,UniqueClass3,4,0,6,0,0.08527
14/12/2012,PupilName5,UniqueClass3,5,0,12,0,0.08527
15/12/2012,PupilName1,UniqueClass4,1,0,0,0,0.08527
15/12/2012,PupilName2,UniqueClass4,2,1,25,0.04,0.08527
15/12/2012,PupilName3,UniqueClass4,3,1,29,0.034482759,0.08527
15/12/2012,PupilName4,UniqueClass4,4,1,38,0.026315789,0.08527
16/12/2012,PupilName1,UniqueClass5,1,12,24,0.5,0.08527
16/12/2012,PupilName2,UniqueClass5,2,1,2,0.5,0.08527
16/12/2012,PupilName3,UniqueClass5,3,13,59,0.220338983,0.08527
16/12/2012,PupilName4,UniqueClass5,4,28,359,0.077994429,0.08527
16/12/2012,PupilName5,UniqueClass5,5,0,0,0,0.08527
17/12/2012,PupilName1,UniqueClass6,1,0,0,0,0.08527
17/12/2012,PupilName2,UniqueClass6,2,2,200,0.01,0.08527
17/12/2012,PupilName3,UniqueClass6,3,2,254,0.007874016,0.08527
17/12/2012,PupilName4,UniqueClass6,4,2,278,0.007194245,0.08527
17/12/2012,PupilName5,UniqueClass6,5,1,279,0.003584229,0.08527
So I have created a tiny model dataset, which contains some good examples of where my current methods fall short and how I feel a genetic algorithm can be used to fix this. If we look in the dataset above it contains 6 unique classes the ultimate objective of the algorithm is to create as high as possible correspondence between a rank of an adjusted x/y and the achieved rank in column 3 (zero based referencing.) In uniqueclass1 we have two identical x/y values, now these are comparatively large x/y values if you compare with the average (note the average isn't calculated from this dataset) but it would be common sense to expect that the 3000/9610 is more significant and therefore more likely to have an achieved rank of 1 than the 300/961. So what I want to do is make an adjusted x/y to overcome these differences in dataset sizes using a logarithmic growth relationship defined by the equation:
adjusted xy = ((1-exp(-y*α)) * x/y)) + ((1-(1-exp(-y*α)))*Average xy)
Where α is the only dynamic number
If I can explain my logic a little and open myself up to (hopefully) constructive criticsm. This graph below shows is an exponential growth relationship between size of the data set and the % of x/y contributing to the adjusted x/y. Essentially what the above equation says is as the dataset gets larger the percentage of the original x/y used in the adjusted x/y gets larger. Whatever percentage is left is made up by the average xy. Could hypothetically be 75% x/y and 25% average xy for 300/961 and 95%/5% for 3000/9610 creating an adjusted x/y which clearly demonstrates
For help with understanding the lowering of α would produce the following relationship where by a larger dataset would be requred to achieve the same "% of xy contributed"
Conversly increasing α would produce the following relationship where by a smaller dataset would be requred to achieve the same "% of xy contributed"
So I have explained my logic. I am also open to code snippets to help me overcome the problem. I have plans to make a multitude of genetic/evolutionary algorithms in the future and could really use a working example to pick apart and play with in order to help my understanding of how to utilise such abilities of python. If additional detail is required or further clarification about the problem or methods please do ask, I really want to be able to solve this problem and future problems of this nature.
So after much discussion about the methods available to overcome the problem presented here I have come to the conclusion that he best method would be a genetic algorithm to iterate α in order to maximise the homology/correspondance between a rank of an adjusted x/y and the achieved rank in column 3. It would be greatly greatly appreciated if anyone be able to help in that department?
So to clarify, this post is no longer a discussion about methodology
I am hoping someone can help me produce a genetic algorithm to maximise the homology between the results of the equation
adjusted xy = ((1-exp(-y*α)) * x/y)) + ((1-(1-exp(-y*α)))*Average xy)
Where adjusted xy applies to each row of the csv. Maximising homology could be achieved by minimising the difference between the rank of the adjusted xy (where the rank is by each Unique class only) and Achieved rank.
Minimising this value would maximise the homology and essentially solve the problem presented to me of different size datasets. If any more information is required please ask, I check this post about 20 times a day at the moment so should reply rather promptly. Many thanks SMNALLY.
The problem you are facing sounds to me like "Bias Variance Dilemna" from a general point of view. In a nutshell, a more precise model favours variance (sensitivity to change in a single training set), a more general model favours bias (model works for many training sets)
May I suggest not to focus on GA but look at Instance Base Learning and advanced regression techniques. The Andrew moore page at CMU is a good entry point.
And particularly those slides.
[EDIT]
After a second reading, here is my second understanding:
You have a set of example data with two related attributes X and Y.
You do not want X/Y to dominate when Y is small, (considered as less representative).
As a consequence you want to "weigth" the examples with a adapted value adjusted_xy .
You want adjusted_xy to be related to a third attribute R (rank). Related such as,per class, adjusted_xy is sorted like R.
To do so you suggest to put it as an optimization problem, searching for PARAMS of a given function F(X,Y,PARAMS)= adjusted_xy .
With the constraint that D=Distance( achieved rank for this class, rank of adjusted_xy for this class ) is minimal.
Your question, at least for me, is in the field of attribute selection/attribute adaptation. (I guess the data set will later be used for supervised learning ).
One problem that I see in your approach (if well understood) is that, at the end, rank will be highly related to adjusted_xy which will bring therefore no interesting supplementary information.
Once this said, I think you surely know how GA works . You have to
define the content of the chromosome : this appears to be your alpha parameter.
define an appropriate fitness function
The fitness function for one individual can be a sum of distances over all examples of the dataset.
As you are dealing with real values , other metaheuristics such as Evolution Strategies (ES) or Simulated Anealing may be more adapted than GA.
As solving optimization problems is cpu intensive, you might eventually consider C or Java instead of Python. (as fitness at least will be interpreted and thus cost a lot).
Alternatively I would look at using Y as a weight to some supervised learning algorithm (if supervised learning is the target).
Let's start by the problem: You consider the fact that some features lead to some of your classes a 'strike'. You are taking a subset of your data and try to establish a rule for the strikes. You do establish one but then you notice that the accuracy of your rule depends on the volume of the dataset that was used to establish the 'strike' rate anyway. You are also commenting on the effect of some samples in biasing your 'strike' estimate.
The immediate answer is that it looks like you have a lot of variation in your data, therefore you will in one way or another need to collect more to account for that variation. (That is, variation that is inherent to the problem).
The fact that in some cases the numbers end up in 'unusable cases' could also be down to outliers. That is, measurements that are 'out of bounds' for a number of reasons and which you would have to find a way to either exclude them or re-adjust them. But this depends a lot on the context of the problem.
'Strike rates' on their own will not help but they are perhaps a step towards the right direction. In any case, you can not compare strike rates if they are coming from samples of different sizes as you have found out too. If your problem is purely to determine the size of your sample so that your results conform to some specific accuracy then i would recommend that you have a look at Statistical Power and how does the sample size affects it. But still, to determine the sample size you need to know a bit more about your data, which brings us back to point #1 about the inherent variation.
Therefore, my attempt to an answer is this: If i have understood your question correctly, you are dealing with a classification problem in which you seek to assign a number of items (patients) to a number of classes (types of cancer) on the evidence of some features (existence of genetic markers, or frequency of their appearance or any other quantity anyway) about these items. But, some features might not exist for all items or, there is a core group of features but there might be some more that do not appear all the time. The question now is, which classifier do you use to achieve this? Logistic regression was mentioned previously and has not helped. Therefore, what i would suggest is going for a Naive Bayesian Classifier. The classifier can be trained with the datasets you have used to derive the 'strike rates' which will provide the a-priori probabilities. When the classifier is 'running' it will be using the features of new data to construct a likelihood that the patient who provided this data should be assigned to each class.
Perhaps the more common example for such a classifier is the spam-email detectors where the likelihood that an email is spam is judged on the existence of specific words in the email (and a suitable training dataset that provides a good starting point of course).
Now, in terms of trying this out practically (and since your post is tagged with python related tags :) ), i would like to recommend Weka. Weka contains a lot of related functionality including bootstrapping that could potentially help you with those differences in the size of the datasets. Although Weka is Java, bindings exist for it in Python too. I would definitely give it a go, the Weka package, book and community are very helpful.
No. Don't use a genetic algorithm.
The bigger the search space of models and parameters, the better your chances of finding a good fit for your data points. But the less this fit will mean. Especially since for some groups your sample sizes are small and therefore the measurements have a high random component to them. This is why, somewhat counterintuitively, it is often actually harder to find a good model for your data after collecting it than before.
You have taken the question to the programmer's lair. This is not the place for it. We solve puzzles.
This is not a puzzle to find the best line through the dots. You are searching for a model that makes sense and brings understanding on the subject matter. A genetic algorithm is very creative at line-through-dot drawing but will bring you little understanding.
Take the problem back where it belongs and ask the statisticians instead.
For a good model should be based on theory behind the data. It'll have to match the points on the right side of the graph, where (if I understand you right) most of the samples are. It'll be able to explain in hard probabilities how likely the deviations on the left are and tell you if they are significant or not.
If you do want to do some programming, I'd suggest you take the simplest linear model, add some random noise, and do a couple simulation runs for a population like your subjects. See if the data looks like the data you're looking at or if it generally 'looks' different, in which case there really is something nonlinear (and possibly interesting) going on on the left.
I once tackled a similar problem (as similar as problems like this ever are), in which there were many classes and high variance in features per data point. I personally used a Random Forest classifier (which I wrote in Java). Since your data is highly variant, and therefore hard to model, you could create multiple forests from different random samples of your large dataset and put a control layer on top to classify data against all the forests, then take the best score. I don't write python, but i found this link
http://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html
which may give you something to play with.
Following Occam's razor, you must select a simpler model for small dataset and may want to switch to a more complex model as your dataset grows.
There are no [good] statistical tests that show you if a given model, in isolation, is a good predictor of your data. Or rather, a test may tell you that given model fitness is N, but you can never tell what the acceptable value of N is.
Thus, build several models and pick one with better tradeoff of predictive power and simplicity using Akaike information criterion. It has useful properties and not too hard to understand. :)
There are other tests of course, but AIC should get you started.
For a simple test, check out p-value