##### https://github.com/maartenpaul/DBD_tracking

Revision

**9053096f651b1a0bcf0cd28a9f961cf70206a55a**authored by Maarten Paul on**19 July 2021, 11:04:05 UTC**, committed by GitHub on**19 July 2021, 11:04:05 UTC****1 parent**766b6b0

Tip revision:

**9053096f651b1a0bcf0cd28a9f961cf70206a55a**authored by**Maarten Paul**on**19 July 2021, 11:04:05 UTC****Update analysis script v2.R** Tip revision:

**9053096** Get_predictions.py

```
# Get predicted/original states
reshapedTracks = []
numFeat = 1 + ('meanMSD' in addFeat) * maxOrder + ('xy' in addFeat) * 4
allStates = []
for fv in featVec:
track = np.array(fv).reshape(1, len(fv), numFeat)
predicted = model.predict(track)
predSt = predicted.argmax(axis = 2)
reshapedTracks.append(track)
allStates.append(predSt[0])
# Get lists of distances in state 0, 1 and 2
state0 = []
state1 = []
state2 = []
state012 = []
for pred, tr in zip(allStates, reshapedTracks):
for i in range(len(pred)):
state012.append(tr[0][i][0])
if pred[i] == 0:
state0.append(tr[0][i][0])
elif pred[i] == 1:
state1.append(tr[0][i][0])
else:
state2.append(tr[0][i][0])
state0 = np.sort(state0)
state1 = np.sort(state1)
state2 = np.sort(state2)
state012 = np.sort(state012)
# Calculate D0, D1 and D2 from state0, state1 and state2
mean0 = ((pixSize * np.array(state0)) ** 2).mean()
mean1 = ((pixSize * np.array(state1)) ** 2).mean()
mean2 = ((pixSize * np.array(state2)) ** 2).mean()
# Brownian motion: D = (mean(d^2)) / (4 * time step)
D0 = mean0 / (4 * t)
D1 = mean1 / (4 * t)
D2 = mean2 / (4 * t)
print('Brownian motion: D0 (fast): %.6f, D1 (slow): %.6f, D2 (immobile): %.6f\
\t(D = (mean(d^2) / (4 * time step))' %(D0, D1, D2))
# Rayleigh: D = mean(d)^2 / (pi * time step)
DD0 = (np.array(state0).mean() * pixSize) ** 2 / math.pi / t # (Rayleigh)
DD1 = (np.array(state1).mean() * pixSize) ** 2 / math.pi / t # (Rayleigh)
DD2 = (np.array(state2).mean() * pixSize) ** 2 / math.pi / t # (Rayleigh)
print('Rayleigh:\t D0 (fast): %.6f, D1 (slow): %.6f, D2 (immobile): %.6f\
\t(D = mean(d)^2 / (pi * time step))\n' %(DD0, DD1, DD2))
#Get probability transition matrix P = P[[p00, p01], [p10, p11]]
Step00 = 0
Step01 = 0
Step02 = 0
Step10 = 0
Step11 = 0
Step12 = 0
Step20 = 0
Step21 = 0
Step22 = 0
for pred in allStates:
for i in range(len(pred) - 1):
if pred[i] == 0:
if pred[i + 1] == 0:
Step00 += 1
elif pred[i + 1] == 1:
Step01 += 1
elif pred[i + 1] == 2:
Step02 += 1
elif pred[i] == 1:
if pred[i + 1] == 0:
Step10 += 1
elif pred[i + 1] == 1:
Step11 += 1
elif pred[i + 1] == 2:
Step12 += 1
elif pred[i] == 2:
if pred[i + 1] == 0:
Step20 += 1
elif pred[i + 1] == 1:
Step21 += 1
elif pred[i + 1] == 2:
Step22 += 1
p00 = round(Step00 / (Step00 + Step01 + Step02), 3)
p01 = round(Step01 / (Step00 + Step01 + Step02), 3)
p02 = round(Step02 / (Step00 + Step01 + Step02), 3)
p10 = round(Step10 / (Step10 + Step11 + Step12), 3)
p11 = round(Step11 / (Step10 + Step11 + Step12), 3)
p12 = round(Step12 / (Step10 + Step11 + Step12), 3)
p20 = round(Step20 / (Step20 + Step21 + Step22), 3)
p21 = round(Step21 / (Step20 + Step21 + Step22), 3)
p22 = round(Step22 / (Step20 + Step21 + Step22), 3)
P = [[p00, p01, p02], [p10, p11, p12], [p20, p21, p22]]
print('Probability transition matrix:\n' + str(np.matrix(P).reshape((3,3))) + '\n')
# Calculate fraction of timepoints spent in state 0/1/2
st0 = 0
st1 = 0
st2 = 0
for pred in allStates:
for i in range(len(pred) - 1):
if pred[i] == 0:
st0 += 1
elif pred[i] == 1:
st1 += 1
else:
st2 += 1
frac0 = st0 / (st0 + st1 + st2)
frac1 = st1 / (st0 + st1 + st2)
frac2 = st2 / (st0 + st1 + st2)
print('Fast fraction:\t\t%.6f\nSlow fraction:\t\t%.6f\nImmobile fraction:\t%.6f\n' %(frac0, frac1, frac2))
```

Computing file changes ...