Are there any way of removing impact of a certain data from a trained model (about "right to forget") I was reading about wearable technologies (Recent Advances in Wearable Sensing Technologies). They briefly talk about Right to forget and a question came to my mind. Suppose that we trained a deep learning model (e.g., CNN) by using face images collected from 1000 participants (10 face images from each participant = 10x1000 images in sum). After training, participant 1 wanted to remove his/her face data from the model. Instead of re-train the model with 999 participants, are there any way of removing the impact of participant 1's data from the trained model? I made a quick search but I could not find it. Did you hear about something like that?
PS: When I think about the forward and backward propagation processes and how we decrease the error, it seems to me to be not possible.
 A: The keyword you're looking for is machine unlearning; if you search for that on Google scholar you'll find a large number of relevant studies. This is an active active area of research for exactly the reason you described. For CNNs, it seems to me that there is not really great solution yet (but I might be wrong).
For example, one solution that people (Bourtoule et al. 2021) have proposed is to split the training data into separate shards (=smaller subdatasets) and then train separate models on each of these shards. For prediction/inference, the output of these separate weak learners can then be combined in various ways (see Boosting). Why is this helpful for unlearning? Well, the influence of a single training point is thereby limited to a single submodel, and if that datapoint must be removed, then "only" this submodel has to be retrained.
There are various other methods proposed, but as I said, it seems to me to be an essentially open research question. A comprehensive reference list can be found here.
Two remarks that may or may not be of interest:

*

*There is a connection to differential privacy, since the latter requires model outputs to be indistinguishable to a certain degree when individual datapoints in the training dataset are substituted. Does this completely eliminate the need for machine unlearning techniques? No. (Imaging what happens when 50% of the training dataset demand that their data be unlearned.)

*How hard machine unlearning is depends largely on the considered model class. E.g., for linear Gaussian models and Gaussian Processes, simple recursive updating rules exist that can be exploited very cheaply. (Think recursive least squares, just in reverse.) In general, I think if a model class allows for a simple, closed-form recursive update procedure to include a single new datapoint, then it will also be possible to do the same thing in reverse. This obviously excludes all models that are batch-trained using numerical optimization procedures.

A: It is possible, but amounts to the same effort as retraining the model.

The weights $\theta$ at iteration $t$ (a mini-batch within an epoch) are defined as:
$$\theta_t=\theta_{t-1}-\nabla_{\theta_{t-1}}\mathcal L_{t-1}$$
By recursion, it becomes obvious that:
$$\theta_t=\theta_0-\sum_{i=0}^{t-1}\nabla_{\theta_i}\mathcal L_i$$
Where $\mathcal L_i$ is the mini-batch loss function at a given iteration (again, mini-batch within epochs).
So, even when said data-point you want to remove is not included in the mini-batch, its effect is still present in the current state of the weights due to the previous iterations, where it was used to derive a gradient.
To fully remove the effects of a data-point, you'd have to backtrack weights all the way back to the first time it was used to derive gradients.
Then, you'd calculate it's individual contribution to the gradient and remove that.
But, the next iteration would be using a new set of weights, which means that the new loss function calculation would need to be redone.
In other words, it's the same effort of retraining the whole model in most applications (I'm sure some very specific training schemes and architectures might allow for simpler solutions).
