PENTA’s imperative for pitch target for each syllable comes from its core assumption about speech articulation, as represented by the TA model shown in Fig. 2. That is, the F0 contour of every syllable comes from a single mechanism: articulatory approximation of an underlying pitch target in synchrony with the syllable. Thus there is no other way of generating an F0 contour for a syllable than assigning it an underlying pitch target. (Xu et al. 2015, p. 515)
there is evidence, as will be discussed later, that not only stressed syllables but also unstressed syllables are assigned functionbased contrastive pitch targets.” (Xu et al., 2015, p. 516)
Finally, in terms of economy of representation, the assumption of one target per syllable may not be as uneconomical as it appears. This is because, although each syllable needs to be assigned a target, the target can be the same for all syllables with the same functional status in terms of lexical tone, lexical stress, focus, modality (i.e. question vs. statement), boundary marking, etc.” (Xu et al., 2015, p. 516)
Tune-text independence: abstraction across length (and stress position) of segmental material: constant melody (tune), even if text is different
However, we believe that their reply does not address the key point of our earlier paper (Arvaniti & Ladd 2009), which was that syllable-by-syllable specification of F0 does not makes theoretical sense in a language where F0 functions at the phrase or utterance level, and does not permit adequate quantitative modelling of complex intonation contours in short utterances. (Arvaniti and Ladd, 2015, p. 537)
the issue is whether every syllable needs an underlying pitch specification at all. (Arvaniti and Ladd, 2015, p. 538)
Problems with PENTA model for short utterances?
Defining contours in terms of such landmarks entails the existence of what we termed SPARSE TONAL SPECIFICATION: there need not be an intonational target for every syllable, and the F0 on any given syllable may reflect nothing more than a transition between an earlier target and a later one. Conversely, in short utterances, a syllable may bear two or more intonational specifications. (Arvaniti and Ladd, 2015, p. 537)
Xu et al. account for our finding that the nuclear high peak is aligned earlier in stress clash contexts by invoking the ‘target strength’ of the immediately following stressed syllable. They note (2015: §4.2.1) that ‘because there is no anticipatory mechanism in qTA’, more distant stressed syllables would not be expected to have any such effect, which is consistent with Arvaniti & Ladd’s paper. However, they do not mention our finding (2009: 58) that the effect of stress clash is significantly greater in short sentences than in long ones, which does seem to require look-ahead.” (Arvaniti and Ladd, 2015, p. 539)
In Mandarin, F0 does need to be lexically specified for every syllable if it is to be properly modelled phonetically, and PENTA provides an elegant and accurate model of Mandarin F0 contours. However, because they believe that PENTA captures something fundamental about how F0 functions in all languages, Xu et al. assume that F0 in any language must therefore be controlled by syllable-by-syllable specifications. (Arvaniti and Ladd, 2015, p. 540)
The second position is that PENTA considers articulatory mechanisms as essential, and incorporates them into the core of its theoretical framework. In this way a large portion of the surface prosodic patterns, e.g. in terms of alignment, scaling, etc., is attributed to obligatory articulatory processes rather than to phonology. (Xu et al., 2015, p. 508)
It has always been assumed in the PENTA model, though not always made fully explicit in published work, that some of the encoding schemes are highly stylised and language-specific, while others are more gradient and universal.” (Xu et al., 2015, p. 510)

Despite the assumption of a direct link between encoding schemes and communicative functions, PENTA does not directly link communicative functions to surface prosody. Rather, it assumes that communicative functions are linked to surface prosody both through articulatory mechanisms that are universal and through encoding schemes that are either universal or language-specific.” (Xu et al., 2015, p. 511)
The PARALLEL ENCODING AND TARGET APPROXIMATION (PENTA) model of speech prosody was proposed as an attempt to improve the understanding of prosody by putting emphasis on two aspects of speech prosody that had not received sufficient attention, namely, communicative functions and articulatory mechanisms (Xu 2005). The goal was to develop a framework that would explain how speech prosody works as a system of communication. More specifically, the framework to be developed should be able to describe how prosody can enable a rich repertoire of communicative functions to be simultaneously realised by an articulatory system, so that all the details of the surface prosody can be traced back to their proper sources.” (Xu et al., 2015, p. 506)
The functions are arranged in a stack to indicate that they are parallel to one another, i.e. with no hierarchical relations, hence the key word PARALLEL in the name of the model” (Xu et al., 2015, p. 509)
Thus the PENTA approach is based on two key positions. The first is that prosodic contrasts are defined functionally, rather than by formal categories. This position touches on the fundamental issue of the role of phonology as a level of abstract representation in speech prosody. In the PENTA model, representational units are contrastive not because they are distinct from each other, but because they serve to distinguish specific functional categories (or to represent functional dimensions if they are not categorical). (Xu et al., 2015, p. 508)
Does PENTA assume cross-linguistic, unified expression of focus?
Unlike PENTA, that is, it [AM theory] does not assume that certain very specific communicative functions like ‘focus’ are easily definable and identifiable across languages.(Arvaniti and Ladd, 2015, p. 538)
Thus the encoding scheme of focus in languages like Mandarin and English are multi-componential, language-specific, and probably with historical etymologies – very similar to lexical morphemes.” (Xu et al., 2015, p. 512)
One example definition from preface to Dieter Fensel book or also see wikipedia entry
Researchers in Artificial Intelligence have traditionally been classified into two categories: the “neaties” and the “scruffies”. According to the scruffies, the neaties concentrate on building elegant formal frameworks, whose properties are beautifully expressed by means of definitions, lemmas, and theorems, but which are of little or no use when tackling real-world problems. The scruffies are described (by the neaties) as those researchers who build superficially impressive systems that may perform extremely well on one particular case study, but whose properties and underlying theories are hidden in their implementation, if they exist at all.
To what extent does AM theory allow testing of hypotheses down to predictions about the f0 contour?
Generalization beyond the data?
“In effect, as argued by Arvaniti (2007a), Xu’s model is both more powerful than it needs to be to account for phonetic variation, and not powerful enough to account for generalisations beyond phonetic form.” (Arvaniti and Ladd, 2009, p. 65)
PENTA specifies underlying syllabic tonal targets--is there a mechanism of generalization at this level of underlying targets, rather than the surface level?
“PENTAtrainer1 takes a two-phase approach. In Phase 1, an optimal target is obtained for each syllable of each utterance by comparing the performance of all possible combinations of the three target parameters (\(b\), \(m\), \(\lambda\) in (1)). The parameter set that achieves the best fit to the F0 contour of a specific syllable (i.e. with the smallest sum square errors) is selected as its pitch target. An example of such resynthesis is shown in Fig. 5, where the short dashed lines are the learned targets. The F0 contours generated with these learned targets (solid lines) seem to fit the original F0 contours (dotted lines) quite well. In Phase 2, categorical targets are obtained by averaging over the parameters of all the syllables in the corpus that belong to the same categorical combination, e.g. all the on-focus H tones that occur at the beginning of a sentence (Prom-on et al. 2009). This approach can be referred to as CATEGORISATION BY AVERAGING. As found in Prom-on et al. (2009) and Liu et al. (2013), good predictive results can be obtained for both English and Mandarin.
The categorisation by averaging strategy employed in PENTAtrainer1, despite its reasonable performance, cannot satisfactorily estimate all qTA parameters. In particular, locally estimated parameters may not be globally optimal. For example, in some cases, the rate of target approximation (l) may not be adequately estimated if there is severe target undershoot. Besides, the simple exhaustive search implemented in PENTAtrainer1 is inefficient, and probably biologically unrealistic as a learning algorithm.” (Xu et al., 2015, p. 519)
Averaging/marginalizing over which contextual factors?
What are the various parameters learned? It's the number of \(b\), \(m\), \(\lambda\) values needed for each separate "level" of combination of contextual factors (so number of parameters should always be divisible by 3)
How is each syllable specified? 3rd order critically damped linear system
\[ f_0(t) = (mt+b) + (c_1 + c_2t + c_3t^2)e^{-\lambda t} \]
Equations for velocity and acceleration not in 2015 paper, but among other places, in the Praat script _qTA_trainer.praat (and you can derive yourself by differentiating with respect to \(t\)):
\[ f_0'(t) = -\lambda (c_3t^2 + c_2t +c_1)e^{-\lambda t} + (2c_3t + c_2)e^{-\lambda t} + m \]
\[ f0''(t) = \lambda^2(c_3 t^2 + c_2t + c_1)e^{-\lambda t} - 2 \lambda (2c_3t +c_2)e^{-\lambda t} + 2c_3e^{-\lambda t} \]
where
\(m\) is the pitch target slope (negative means falling, positive means rising f0)
\(b\) is the pitch target height, relative to speaker's average F0; positive means higher than average, negative means lower than average
\(c_1\), \(c_2\), \(c_3\) are "transient coefficients...calculated based on the initial F0 dynamic state and pitch target of current syllable"
\(\lambda\) is "the strength of the F0 movement toward the target": higher values indicate faster approach towards pitch target from initial f0
Equations for computing transient coefficients:
\[ c_1 = f_0(0) -b \\ c_2 = f_0'(0) +c_1\lambda -m \\ c_3 = \frac{f_0''(0) + 2c_2\lambda - c_1\lambda^2)}{2} \]
where
and these are set to the final values from the immediately preceding syllable ("state transfer")
| Section | Details | Lines |
|---|---|---|
| Documentation | 1-167 | |
| User input form | 170-201 | |
| Variable initialization | 207-225 | |
| Create file list | 227-239 | |
| Set variables for file creation | 240-248 | |
Iterate through files and generate means, normf0, samplf0, f0velocity |
ProsodyPro procedures | 249-265 |
| Print info about generated files | 267-283 | |
Labeling(file_name, file_extension) |
Creates tiers for variables, allows user to label TextGrids | 285-357 |
Save(directory, name) |
Calls Trimf0, Sampling, Differentiation, Smooth, Normalization, Means |
359-461 |
Trimf0 |
No args? Calls Trim | 463-482 |
Trim |
no args? | 484-526 |
Normalization(pitchtier, tableOfReal1, tableOfReal2) |
Calls Normalize(pitchtier, tableOfREal1, tableOfReal2) |
528-585 |
Normalize(pitchtier, tableOfREal1, tableOfReal2) |
Computes normalized f0 | 587-618 |
Sampling |
Computes f0 with specified sampling rate, not sure how f0_sample_rate gets passed in |
620-672 |
Differentiation |
converts to semitone, calls Smooth, computes velocity (differences between sample points) and averages computed difference between two sample points, calls Smooth on velocity computed |
674-743 |
Means |
Computes some f0 and intensity values and calls qTA _synthesis to resynthesize |
745-1007 |
All_means(file_name) |
Compiles means output files from all sounds | 1009-1115 |
All_normf0(filename) |
Compiles normalized f0 output files from all sounds | 1117-1159 |
All_samplef0(filename) |
Compiles sampled f0 values from all sounds | 1161-1187 |
All_f0velocity(filename) |
Compiles velocities from all sounds | 1189- 1125 |
All_qTAf0(filename) |
Compiles qTA computed f0 values from all sounds | 1217-1243 |
Smooth(curve_in, curve_out, width) |
Seems to smooth based on doing a weighted average over preceding and following points?? | 1245-1319 |
correlation(index_initial,index_final) |
Computes correlation between raw and qTA f0 values | 1321-1353 |
Target |
1356-1659 | |
plot_target(t1,t2) |
Creates visualization of resynthesized f0, calls on_input |
1661-1827 |
on_input |
GUI/button interface for visualization window | 1829-2045 |
qTA_synthesis |
Initializes \(f0\), \(f0'\), \(f0''\), calls qTA passing in params, calculates RMSE |
2047-2186 |
qTA(mn, bb, lambda, nsamples) |
Computes transient coefficients, f0, f0', f0'' | 2188-2207 |
Note: left and right are for formatting Praat's user input window
For f0 analysis:
| User input name | Script internal name | Default value |
|---|---|---|
| left_f0_range (Hz) | minf0 | 30 |
| right_f0_range (Hz) | maxf0 | 400 |
| npoints_per_interval | npoints | 10 |
| f0 sample rate (Hz) | 100 | |
| perturbation_length (ms) | 0 | |
| final_offset | -0.03 | |
| smoothing_window_width (s) | 0.07 | |
| set_initial_time_for_normf0_to_0 | 1 |
For target extraction:
| User input name | Script internal name | Default value |
|---|---|---|
| left_target_slope_range (st/s) | min_target_slope | -100 |
| right_target_slope_range (st/s) | max_target_slope | 100 |
| left_target_height_range (st) | min_target_height | -20 |
| right_target_height_range (st) | max_target_height | 20 |
| left_strength_range | min_strength | 1 |
| right_strength_range | max_strength | 80 |
| minimum_pause_duration (ms) | 150 | |
| fix_strength_to_minimum_strength | fixed_strength | 0 |
| use_final_velocity_to_constrain_slope | 0 |
The qTA procedure is called on line 2127 in the qTA_synthesis procedure:
call qTA m b-m*duration+xInitial lambda nsamplesCan you explain why it passes in what it does to qTA?
Note that qTA_synthesis itself is called on line 838 in the Means procedure, without passing in any arguments.
qTA, lines 2188-2207
procedure qTA mn bb lambda nsamples
delta = 1/f0_sample_rate
t = 0
c1 = x0 - bb
c2 = v0 + c1 * lambda - mn
c3 = (a0 + 2 * c2 * lambda - c1 * lambda^2) / 2
for i from 1 to nsamples
t += delta
y = (mn * t + bb) + (c1 + c2 * t + c3 * t^2) * exp(-lambda * t)
v = -lambda * (c3 * t^2 + c2 * t + c1) * exp(-lambda * t) + (2 * c3 * t + c2) * exp(-lambda * t) + mn
select PitchTier fittedf0_st
Add point... t+start y
select PitchTier fittedvelocity
Add point... t+start v
endfor
xFinal = y
vFinal = v
aFinal = lambda^2 * (c3 * t^2 + c2 * t + c1) * exp(-lambda * t) - 2 * lambda * (2 * c3 * t + c2) * exp(-lambda * t) + 2 * c3 * exp(-lambda * t)
endproc