Datasets:
shibing624
/
source_code

Dataset card Data Studio Files Community
2
text
stringlengths
0
2.2M
auto* target = &_target[b * _L];
auto* transBatchGrad = &ws.transBatchGrad[b * N * N];
auto* transBuf1 = &ws.transBuf1[b * _L];
auto* transBuf2 = &ws.transBuf2[b * _L];
auto* transBufGrad1 = &ws.transBufGrad1[b * _L];
auto* transBufGrad2 = &ws.transBufGrad2[b * _L];
int L = targetSize[b];
alphaGrad[T * L - 1] = 1;
for (int t = T - 1; t > 0; --t) {
auto* inputCurGrad = &inputGrad[t * N];
auto* alphaPrev = &alpha[(t - 1) * L];
auto* alphaCurGrad = &alphaGrad[t * L];
auto* alphaPrevGrad = &alphaGrad[(t - 1) * L];
int high = t < L ? t : L;
int low = T - t < L ? L - (T - t) : 1;
int high1 = t < L ? t + 1 : L;
int low1 = T - t < L ? L - (T - t) : 0;
for (int i = low1; i < high1; ++i) {
inputCurGrad[target[i]] += alphaCurGrad[i];
}
if (T - t >= L) {
alphaPrevGrad[0] += alphaCurGrad[0];
transBufGrad1[0] += alphaCurGrad[0];
}
if (t < L) {
alphaPrevGrad[high - 1] += alphaCurGrad[high];
transBufGrad2[high] += alphaCurGrad[high];
}
for (int i = low; i < high; ++i) {
double s1 = alphaPrev[i] + transBuf1[i];
double s2 = alphaPrev[i - 1] + transBuf2[i];
// d1, d2 = dLogSumExp(s1, s2)
double d1, d2;
if (s1 < s2) {
d2 = 1 / (1 + exp(s1 - s2));
d1 = 1 - d2;
} else {
d1 = 1 / (1 + exp(s2 - s1));
d2 = 1 - d1;
}
alphaPrevGrad[i] += d1 * alphaCurGrad[i];
alphaPrevGrad[i - 1] += d2 * alphaCurGrad[i];
transBufGrad1[i] += d1 * alphaCurGrad[i];
transBufGrad2[i] += d2 * alphaCurGrad[i];
}
}
inputGrad[target[0]] += alphaGrad[0];
auto gradScale = grad[b] * ws.scale[b];
for (int i = 0; i < T * N; ++i) {
inputGrad[i] *= gradScale;
}
for (int i = 0; i < L; ++i) {
transBatchGrad[target[i] * N + target[i]] += transBufGrad1[i];
if (i > 0) {
transBatchGrad[target[i] * N + target[i - 1]] += transBufGrad2[i];
}
}
}
for (int b = 0; b < B; ++b) {
auto transBatchGrad = ws.transBatchGrad + b * N * N;
auto gradScale = grad[b] * ws.scale[b];
for (int i = 0; i < N * N; ++i) {
transGrad[i] += gradScale * transBatchGrad[i];
}
}
}
template <class Float>
void ForceAlignmentCriterion<Float>::viterbi(
int B,
int T,
int N,
int _L,
const Float* _input,
const int* _target,
const int* targetSize,
const Float* trans,
int* bestPaths,
void* workspace) {
WorkspacePtrs<Float> ws(workspace, B, T, N, _L);
#pragma omp parallel for num_threads(B)
for (int b = 0; b < B; ++b) {
double* alpha = &ws.alpha[b * T * _L];
const Float* input = &_input[b * T * N];
const int* target = &_target[b * _L];
Float* transBuf1 = &ws.transBuf1[b * _L];
Float* transBuf2 = &ws.transBuf2[b * _L];
int L = targetSize[b];