Package: pytorch-influence-functions
Influence Functions for PyTorchThis is a PyTorch reimplementation of Influence Functions from the ICML2017 best paper:Understanding Black-box Predictions via Influence Functionsby Pang Wei Koh and Percy Liang.
The reference implementation can be found here:link.Why Use Influence Functions?RequirementsInstallationUsageBackground and DocumentationconfigMisc parametersCalculation parameterss_testModes of computationOutput variablesInfluencesHarmfulHelpfulRoadmapv0.2v0.3v0.4Why Use Influence Functions?Influence functions help you to debug the results of your deep learning model
in terms of the dataset. When testing for a single test image, you can then
calculate which training images had the largest result on the classification
outcome. Thus, you can easily find mislabeled images in your dataset, or
compress your dataset slightly to the most influential images important for
your individual test dataset. That can increase prediction accuracy, reduce
training time, and reduce memory requirements. For more details please see
the original paper linkedhere.Influence functions can of course also be used for data other than images,
as long as you have a supervised learning problem.RequirementsPython 3.6 or laterPyTorch 1.0 or laterNumPy 1.12 or laterTo run the tests, further requirements are:torchvision 0.3 or laterPILInstallationYou can either install this package directly through pip:pip3install--userpytorch-influence-functionsOr you can clone the repo and import it as a package after it's in yourPATH.UsageCalculating the influence of the individual samples of your training dataset
on the final predictions is straight forward.The most barebones way of getting the code to run is like this:importpytorch_influence_functionsasptif# Supplied by the user:model=get_my_model()trainloader,testloader=get_my_dataloaders()ptif.init_logging()config=ptif.get_default_config()influences,harmful,helpful=ptif.calc_img_wise(config,model,trainloader,testloader)# do someting with influences/harmful/helpfulHere,configcontains default values for the influence function calculation
which can of course be changed. For details and examples, lookhere.Background and DocumentationThe precision of the output can be adjusted by using more iterations and/or
more recursions when approximating the influence.configconfigis a dict which contains the parameters used to calculate the
influences. You can get the defaultconfigby callingptif.get_default_config().I recommend you to change the following parameters to your liking. The list
below is divided into parameters affecting the calculation and parameters
affecting everything else.Misc parameterssave_pth: DefaultNone, folder where to saves_testandgrad_zfiles
if saving is desiredoutdir: folder name to which the result json files are writtenlog_filename: DefaultNone, if set the output will be logged to this
file in addition tostdout.Calculation parametersseed: Default = 42, random seed for numpy, random, pytorchgpu: Default = -1,-1for calculation on the CPU otherwise GPU idcalc_method: Default = img_wise, choose between the two calculation methods
outlinedhere.DataLoaderobject for the desired datasettrain_loaderandtest_loadertest_sample_start_per_class: Default = False, per class index from where to
start to calculate the influence function. IfFalse, it will start from0.
This is useful if you want to calculate the influence function of a whole
test dataset and manually split the calculation up over multiple threads/
machines/gpus. Then, you can start at various points in the dataset.test_sample_num: Default = False, number of samples per class
starting from thetest_sample_start_per_classto calculate the influence
function for. E.g. if your dataset has 10 classes and you set this value to1, then the influence functions will be calculated for10 * 1test
samples, one per class. IfFalse, calculates the influence for all images.s_testrecursion_depth: Default = 5000, recursion depth for thes_testcalculation.
Greater recursion depth improves precision.r: Default = 1, number ofs_testcalculations to take the average of.
Greater r averaging improves precision.Combined, the original paper suggests thatrecursion_depth * rshould equal
the training dataset size, thus the above values ofr = 10andrecursion_depth = 5000are valid for CIFAR-10 with a training dataset size
of 50000 items.damp: Default = 0.01, damping factor durings_testcalculation.scale: Default = 25, scaling factor durings_testcalculation.Modes of computationThis packages offers two modes of computation to calculate the influence
functions. The first mode is calledcalc_img_wise, during which the two
valuess_testandgrad_zfor each training image are computed on the fly
when calculating the influence of that single image. The algorithm moves then
on to the next image. The second mode is calledcalc_all_grad_then_testand
calculates thegrad_zvalues for all images first and saves them to disk.
Then, it'll calculate alls_testvalues and save those to disk. Subsequently,
the algorithm will then calculate the influence functions for all images by
reading both values from disk and calculating the influence base on them. This
can take significant amounts of disk space (100s of GBs) but with a fast SSD
can speed up the calculation significantly as no duplicate calculations take
place. This is the case becausegrad_zhas to be calculated twice, once for
the first approximation ins_testand once to combine with thes_testvector to calculate the influence. Most importantnly however,s_testis only
dependent on the test sample(s). While onegrad_zis used to estimate the
initial value of the Hessian during thes_testcalculation, this is
insignificant.grad_zon the other hand is only dependent on the training
sample. Thus, in thecalc_img_wisemode, we throw away allgrad_zcalculations even if we could reuse them for all subsequents_testcalculations, which could potentially be 10s of thousands. However, as stated
above, keeping thegrad_zs only makes sense if they can be loaded faster/
kept in RAM than calculating them on-the-fly.TL;DR: The recommended way is usingcalc_img_wiseunless you have a crazy
fast SSD, lots of free storage space, and want to calculate the influences on
the prediction outcomes of an entire dataset or even >1000 test samples.Output variablesVisualised, the output can look like this:The test image on the top left is test image for which the influences were
calculated. To get the correct test outcome ofship, the Helpful images from
the training dataset were the most helpful, whereas the Harmful images were the
most harmful. Here, we used CIFAR-10 as dataset. The model was ResNet-110. The
numbers above the images show the actual influence value which was calculated.The next figure shows the same but for a different model, DenseNet-100/12.
Thus, we can see that different models learn more from different images.InfluencesIs a dict/json containting the influences calculated of all training data
samples for each test data sample. The dict structure looks similiar to this:{"0":{"label":3,"num_in_dataset":0,"time_calc_influence_s":129.6417362689972,"influence":[-0.00016939856868702918,4.3426321099104825e-06,-9.501376189291477e-05,...],"harmful":[31527,5110,47217,...],"helpful":[5287,22736,3598,...]},"1":{"label":8,"num_in_dataset":1,"time_calc_influence_s":121.8709237575531,"influence":[3.993639438704122e-06,3.454859779594699e-06,-3.5805194329441292e-06,...HarmfulHarmful is a list of numbers, which are the IDs of the training data samples
ordered by harmfulness. If the influence function is calculated for multiple
test images, the harmfulness is ordered by average harmfullness to the
prediction outcome of the processed test samples.HelpfulHelpful is a list of numbers, which are the IDs of the training data samples
ordered by helpfulness. If the influence function is calculated for multiple
test images, the helpfulness is ordered by average helpfulness to the
prediction outcome of the processed test samples.Roadmapv0.2makes variable names etc. dataset independentremove all dataset name checks from the codeability to disable shell output eg fordisplay_progressfrom the configadd proper result plotting supportadd a dataloader for training on the most influential samples onlyadd some visualisation of the outcomeadd recreation of some graphs of the original paper to verify
implementationv0.3make the config a class, so that it can readjust itself, for example
when therandrecursion_depthvalues can be lowered without big impactcheck killing data augmentation!?incalc_influence_function.pyinload_s_test,load_grad_zdon't
hard code the filenamesv0.4integrate myPy type annotations (static type checking)Use multiprocessing to calc the influenceuser"doc"docstrings like pytorch