Version info: Code for this page was tested in Stata 12.1.
This code fragment page shows an example using Mata to write a function that
generates anonymized keys for wide data such as for participants who rate
other participants or indicate who they know or are close to.
In this example, we have collected data on some school children. Each
child in the study gets a unique ID, and their grade and sex are recorded.
They are also asked to nominate their three closest friends. These friends
may either be in the study or not. If the friends are in the study, we
will have their IDs and the friend’s friends. However, some friends may
not have been in the study, in which case they get their own ID too. Thus
although the IDs in the id column are unique, they are not exhaustive.
If these IDs could lead back to the kids, we may want to anonymize the data, but
generating delinked IDs. However, all the IDs need to be recoded, both those in the
id column and those for the friends. Also note that some children do not
have three close friends so the IDs for some friends are missing.
Here is some example data.
/* some example data */
clear
input id grade sex friend1 friend2 friend3
1 5 0 2 3 14
2 6 0 1 3 14
3 6 0 1 2 14
4 5 1 1 2 3
5 7 0 1 . .
6 6 1 2 4 5
7 5 1 4 6 .
end
/* list the data, Stata style */
list
+------------------------------------------------+
| id grade sex friend1 friend2 friend3 |
|------------------------------------------------|
1. | 1 5 0 2 3 14 |
2. | 2 6 0 1 3 14 |
3. | 3 6 0 1 2 14 |
4. | 4 5 1 1 2 3 |
5. | 5 7 0 1 . . |
|------------------------------------------------|
6. | 6 6 1 2 4 5 |
7. | 7 5 1 4 6 . |
+------------------------------------------------+
In order to generate and recode the ids, we will write a short Mata function,
called genKey. This function takes a single argument, a string vector
containing the names of all the variables containing IDs to be recoded. For
all the variables specified, genKey will create a list of unique values,
create anonymous values for them, recode the values, and then replace the values
in the Stata dataset with the new recoded IDs. Note that the function can handle
missing data and leaves missing IDs as missing.
First we will run the Mata code to define the function. To do this, in Stata,
open a do file editor, copy and paste the code, highlight all of it and do it at once.
This will not return output, but will have the function saved and available for use.
/* Create mata function generate anonymous keys */
mata
void genKey(string vector vars) {
D = st_data(., vars)
longD = colshape(D, 1)
UID = uniqrows(longD)
UID = (UID, uniform(rows(UID), 1))
UID = sort(UID, 2)
lookup = (UID[, 1], (1::rows(UID)))
res = (longD, longD, (1::rows(longD)))
for (i=1;i<=rows(lookup);i++) {
index = select(res[, 3], lookup[i, 1] :== res[, 1])
res[index, 2] = J(rows(index), 1, lookup[i, 2])
}
index = select(res[, 3], res[, 1] :== .)
res[index, 2] = res[index, 1]
res = colshape(res[, 2], cols(D))
st_store((1, rows(res)), st_varindex(vars), res)
}
end
/* end mata function creation */
Now it is easy to use this function to recode our data to
anonymous IDs. Note that because the IDs are random, everytime
you run the function, the results will be different unless you work
to set the random seed (which we do not show here).
/* list original data */
list
+------------------------------------------------+
| id grade sex friend1 friend2 friend3 |
|------------------------------------------------|
1. | 1 5 0 2 3 14 |
2. | 2 6 0 1 3 14 |
3. | 3 6 0 1 2 14 |
4. | 4 5 1 1 2 3 |
5. | 5 7 0 1 . . |
|------------------------------------------------|
6. | 6 6 1 2 4 5 |
7. | 7 5 1 4 6 . |
+------------------------------------------------+
/* generate random IDs and replace in data */
mata genKey(("id", "friend1", "friend2", "friend3"))
/* list data to see updated IDs */
list
+------------------------------------------------+
| id grade sex friend1 friend2 friend3 |
|------------------------------------------------|
1. | 3 5 0 2 1 8 |
2. | 2 6 0 3 1 8 |
3. | 1 6 0 3 2 8 |
4. | 9 5 1 3 2 1 |
5. | 5 7 0 3 . . |
|------------------------------------------------|
6. | 6 6 1 2 9 5 |
7. | 4 5 1 9 6 . |
+------------------------------------------------+
What happens if we run the function again?
mata genKey(("id", "friend1", "friend2", "friend3"))
list
+------------------------------------------------+
| id grade sex friend1 friend2 friend3 |
|------------------------------------------------|
1. | 2 5 0 4 5 1 |
2. | 4 6 0 2 5 1 |
3. | 5 6 0 2 4 1 |
4. | 7 5 1 2 4 5 |
5. | 6 7 0 2 . . |
|------------------------------------------------|
6. | 9 6 1 4 7 6 |
7. | 3 5 1 7 9 . |
+------------------------------------------------+
The values keep getting reshuffled. This function is simple and for
anonymous IDs, just uses sequential integers, but it does so in a random way by
sorting random values from a uniform distribution.
Note that this function can handle an arbitrary number of IDs (rows in the dataset) as well
as an arbitrary number of variables containing IDs. Further, the variables need not be in
any sort of order nor adjacent to each other.