Fonology package

Phonological Analysis in R

L’extension Fonology (Garcia, 2023) contient des fonctions pertinentes à la recherche phonologique et à l’enseignement de la phonologie. Si vous avez des suggestions, veuillez visiter la page GitHub du projet. Voici quelques diapos sur l’extension (English, français, português).

Nouvelles

Une nouvelle fonction qui compte le nombre de syllabes dans une chaîne de caractères a été ajoutée à l’extension: countSyl(). Des fonctions pour analyser des âges en format aa:mm (fréquemment utilisé dans la recherche sur l’acquisition du langage) ont été ajoutée à l’extension. La transcription phonémique pour l’espagnol (beta) est plus précise. Les fonctions qui utilisent les traits distinctifs acceptent maintenant votre inventaire phonémique personnalisé.

L’installation

library(devtools)
install_github("guilhermegarcia/fonology")

Les fonctions principales et les données

  • getFeat() et getPhon() pour les traits distinctifs
  • ipa() pour la transcription phonémique en portugais et en espagnol
  • syllable() pour l’extraction des sous-constituants syllabiques
  • sonDisp() calcule la dispersion de sonorité d’une demi-syllabe donnée. Consultez aussi meanSonDisp() pour calculer la dispersion moyenne dans un groupe de mots
  • wug_pt() pour générer des mots hypothétiques en portugais
  • biGram_pt() pour calculer les probabilités de bigrammes en portugais
  • plotVowels() pour le trapèze vocalique
  • ipa2tipa() traduit des séquences API vers la tipa
  • psl contient le Portuguese Stress Lexicon
  • pt_lex contient une version simplifiée du psl
  • stopwords_pt et stopwords_sp contiennent les mots fonctionnels du portugais et de l’espagnol

Les traits distinctifs

La fonction getFeat() prend un groupe des phonèmes ph et une langue lg et renvoie la matrice minimale des traits distinctifs pour ph étant donné l’inventaire phonémique de la langue lg. Actuellement, cinq langues sont acceptées : l’anglais, le français, l’italien, le portugais, et l’espagnol. Vous pouvez aussi utiliser un inventaire personnalisé. Consultez les exemples ci-dessous.

La fonction getPhon() prend une matrice de traits distinctifs (dans un vecteur en R) ft et une langue lg et renvoie le groupe de phonèmes représenté par ft étant donné l’inventaire phonémique de la langue lg. Les langues disponibles sont les mêmes que dans la fonction getFeat(). Vous pouvez aussi utiliser un inventaire personnalisé.

library(Fonology)

getFeat(ph = c("i", "u"), lg = "English")
#> [1] "+hi"    "+tense"
getFeat(ph = c("i", "u"), lg = "French")
#> [1] "Not a natural class in this language."
getFeat(ph = c("i", "y", "u"), lg = "French")
#> [1] "+syl" "+hi"
getFeat(ph = c("p", "b"), lg = "Portuguese")
#> [1] "-son"  "-cont" "+lab"
getFeat(ph = c("k", "g"), lg = "Italian")
#> [1] "+cons" "+back"
library(Fonology)

getPhon(ft = c("+syl", "+hi"), lg = "French")
#> [1] "u" "i" "y"
getPhon(ft = c("-DR", "-cont", "-son"), lg = "English")
#> [1] "t" "d" "b" "k" "g" "p"
getPhon(ft = c("-son", "+vce"), lg = "Spanish")
#> [1] "z" "d" "b" "ʝ" "g" "v"
library(Fonology)

getFeat(ph = c("p", "f", "w"), 
        lg = c("a", "i", "u", "y", "p", 
               "t", "k", "s", "w", "f"))
#> [1] "-syl" "+lab"

getPhon(ft = c("-son", "+cont"), 
        lg = c("a", "i", "u", "s", "z", 
               "f", "v", "p", "t", "m"))
#> [1] "s" "z" "f" "v"

La transcription API

La fonction ipa() prend un mot (ou un vecteur avec plusieurs mots, réels ou hypothétiques) en portugais ou en espagnol dans sa forme orthographique (word), et renvoie sa transcription phonémique (API), sa syllabation et son accent. La transcription phonétique, qui inclut l’accent secondaire, est générée en ajoutant l’argument narrow = T à la fonction — cette option est disponible pour les mots en portugais seulement. Utilisez ipa_pt_test() et ipa_sp_test() pour générer des exemples. Par défaut, ipa() suppose que lg = "Portuguese" (ou lg = "pt") et narrow = F.

ipa("atlético")
#> [1] "a.ˈtlɛ.ti.ko"
ipa("cantalo", narrow = T)
#> [1] "kãn.ˈta.lʊ"
ipa("antidepressivo", narrow = T)
#> [1] "ˌãn.t͡ʃi.ˌde.pɾe.ˈsi.vʊ"
ipa("feris") 
#> [1] "fe.ˈɾis"
ipa("mejorado", lg = "sp")
#> [1] "me.xo.ˈɾa.do"
ipa("nuevos", lg = "sp")
#> [1] "nu.ˈe.bos"

L’accent lexical

L’extension contient aussi une fonction plus détaillée, ipa_pt(), disponible pour les mots en portugais (cette fonction n’est pas vectorisée). Dans cette fonction, l’accent est attribué à partir de deux scénarios. Premièrement, l’accent pour les mots réels (les noms et les adjectifs) est dérivé de la base de données du Portuguese Stress Lexicon (Garcia, 2014) — si le mot y figure. Deuxièmement, des mots hypothétiques suivent les patrons généraux de l’accent portugais ainsi que les tendances probabilistes démontrées dans ma recherche (Garcia, 2017a, 2017b, 2019). Par conséquent, un mot hypothétique peut avoir l’accent proparoxyton dans des conditions appropriées étant donnée la statistique lexicale du portugais. De même, des mots traditionnellement classés comme irréguliers sont aussi générés de façon probabiliste (p. ex., les paroxytons LH]). L’accent et le poids syllabique sont aussi utilisés pour appliquer les règles de l’abaissement spondaïque et de l’abaissement dactylique, selon le travail de Wetzels (2007). L’accent secondaire est donné si narrow = T. Dans la fonction ipa(), l’accent n’est pas probabiliste (et, donc, il n’est pas variable). Donc, l’accent est attribué catégoriquement pour le portugais et pour l’espagnol.

Des fonctions additionnelles

Si vous voulez tokeniser des textes et créer un tableau avec des variables phonologiques, vous pouvez utiliser quelques fonctions additionnelles qui sont disponibles dans l’extension Fonology. Les fonctions getWeight(), par exemple, prend un mot syllabé et renvoie son poids (p. ex., getWeight("kon.to") renvoie HL, où H = heavy et L = light). La fonction getStress()1 renvoie la position de l’accent dans un mot (si la fenêtre accentuelle contient jusqu’à quatre syllabes) — le mot doit être accentué, mais le symbole utilisé pour l’accent peut être spécifié dans la fonction (l’argument stress). Finalement, countSyl() renvoie le nombre de syllabes dans une chaîne de caractères, et getSyl() extrait des syllabes spécifiques d’un mot.

Voici un exemple de tokenisation d’un petit texte. On va créer un tableau avec quelques variables phonologiques en utilisant les fonctions mentionnées ci-dessus — l’exemple n’utilise pas des extensions telles que tm ou tidytext.

library(tidyverse)
text = "Por exemplo, em quase todas as variedades do português..."

d = tibble(mot = text |>
             cleanText())

d = d |>
  mutate(API = ipa(mot),
         accent = getStress(API), 
         poids = getWeight(API), 
         syl3 = getSyl(API, 3),
         syl2 = getSyl(API, 2),
         syl1 = getSyl(API, 1)) |>
  ungroup() |>
  filter(!mot %in% stopwords_pt) # supprimer les stopwords
mot API accent poids syl3 syl2 syl1
exemplo e.ˈzem.plo penult LHL e zem plo
quase ˈkwa.ze penult LL NA kwa ze
todas ˈto.das penult LH NA to das
variedades va.ɾi.e.ˈda.des penult LLH e da des
português poɾ.tu.ˈges final HLH poɾ tu ges

Si vous voulez extraire les sous-constituants syllabiques, vous pouvez utiliser la fonction syllable() : la fonction prend une syllabe (déjà transcrite phonémiquement) et renvoie le sous-constituant d’intérêt. Ajoutons des colonnes à d pour extraire les constituants de la dernière syllabe (syl1).

d = d |>
  select(-c(syl3, syl2, accent)) |> 
  mutate(at1 = syllable(syl = syl1, const = "onset"),
         no1 = syllable(syl = syl1, const = "nucleus"),
         co1 = syllable(syl = syl1, const = "coda"),
         ri1 = syllable(syl = syl1, const = "rhyme"))
mot API poids syl1 at1 no1 co1 ri1
exemplo e.ˈzem.plo LHL plo pl o NA o
quase ˈkwa.ze LL ze z e NA e
todas ˈto.das LH das d a s as
variedades va.ɾi.e.ˈda.des LLH des d e s es
português poɾ.tu.ˈges HLH ges g e s es

C’est important de décider si on veut classes les semi-voyelles comme attaques ou codas, ou si on veut les classer dans le noyau. Par défaut, syllable() considère que toutes les semi-voyelles sont dans le noyau. Vous pouvez facilement changer ces suppositions en modifiant les arguments glides_as_onsets = TRUE et glides_as_codas = TRUE.

Avez-vous des tonnes de données?

Si vous avez des millions de mots dans un corpus, vous devriez d’abord exécuter ces fonctions sur les types, puis les étendre aux tokens (par exemple, en utilisant right_join() de l’extension dplyr).

[Retour en haut]

Sonorité

Il y a trois fonctions dans l’extension pour analyser la sonorité. Premièrement, demi(word = ..., d = ...) extrait les premières (d = 1, le défaut) ou les deuxièmes (d = 2) demi-syllabes d’un mot ou d’un vecteur de mots. Deuxièmement, sonDisp(demi = ...) calcule la dispersion de sonorité d’une demi-syllabe donnée (Clements, 1990; Parker, 2011). Veuillez noter que cette métrique ne différencie pas des séquences qui respectent le principe de sonorité des celles qui ne le respectent pas, c.-à-d. pla et lpa ont le même score. Pour cette raison, une troisième fonction a été ajoutée :ssp(demi = ..., d = ...), qui évalue si une demi-syllabe respecte (1) or non (0) le principe de sonorité. Dans l’exemple ci-dessous, on prend la dispersion de sonorité de la première demi-syllabe dans la pénultième syllabe — ssp() n’est pas pertinente ici, vu que toutes les syllabes en portugais respectent le principe de sonorité.

exemple = tibble(word = c("partolo", "metrilpo", "vanplidos"))

exemple = exemple |> 
  rowwise() |> 
  mutate(ipa = ipa(word),
         syl2 = getSyl(word = ipa, pos = 2),
         demi1 = demi(word = syl2, d = 1),
         disp = sonDisp(demi = demi1),
         SSP = ssp(demi = demi1, d = 1))
word ipa syl2 demi1 disp SSP
partolo paɾ.ˈto.lo to to 0.06 1
metrilpo me.ˈtɾil.po tɾil tɾi 0.56 1
vanplidos vam.ˈpli.dos pli pli 0.56 1

Vous pouvez aussi calculer la dispersion de sonorité moyenne dans un groupe de mots en utilisant la fonction meanSonDisp(). Si vos mots d’intérêt sont en portugais (réels ou hypothétiques), vous pouvez utiliser leurs formes orthographiques. Sinon, ils doivent être phonémiquement transcrits et syllabés. Dans ce cas-là, utilisez phonemic = T dans la fonction.

meanSonDisp(word = c("partolo", "metrilpo", "vanplidos"))
#> [1] 1.53

[Retour en haut]

La visualisation de la sonorité

La fonction plotSon() utilise ggplot2 pour générer une figure du profil de sonorité d’un mot donné (il faut utiliser sa transcription phonémique). La fonction a été adaptée de l’appli Shiny ici. Si vous voulez afficher la syllabation du mot, il faut utiliser l’argument syl = T — naturellement, le mot doit être syllabé dans ce cas-là (la syllabe accentuée sera automatiquement mise évidence). Finalement, si vous voulez sauver la figure, ajoutez save_plot = T à la fonction. La fonction possède un inventaire phonémique relativement flexible. L’échelle de sonorité utilisée ici a été adaptée à partir de Parker (2011).

"combradol" |> 
  ipa() |> 
  plotSon(syl = F)

"sobremesa" |> 
  ipa(lg = "sp") |> 
  plotSon(syl = T)

[Retour en haut]

Les bigrammes

La fonction biGram_pt() renvoie la probabilité (log) cumulative d’un mot possible en portugais (word). L’argument word doit être transcrit phonémiquement. La base de données de référence utilisée est le Portuguese Stress Lexicon.

biGram_pt("paklode")
#> [1] -43.11171

Deux fonctions additionnelles peuvent être utilisées pour explorer des bigrammes : nGramTbl() génère un tibble avec les bigrammes phonotactiques dans un texte, et plotnGrams() génère une figure (ggplot2) pour l’entrée créée à partir de nGramTbl(). Consultez ?plotnGrams() pour plus d’informations.

Générateur de mots en portugais

La fonction wug_pt() génère un mot hypothétique en portugais. Vous aurez envie (probablement) de faire des ajustements selon vos préférences et les patrons phonotactiques que vous voulez. Pour inclure la palatalisation dans la transcription finale, utilisez palatalization = T — si vous le faites, gardez dans la tête que la fonction biGram_pt() la dépalatasilera, vu qu’elle prend la transcription phonémique de la langue.

set.seed(1)
wug_pt(profile = "LHL")
#> [1] "dɾa.ˈbuɾ.me"
# On va créer un tableau avec 5 mots
set.seed(1)
tibble(word = character(5)) |>
  mutate(word = wug_pt("LHL", n = 5),
         bigram = word |> 
           biGram_pt())
word bigram
dɾa.ˈbuɾ.me -49.23458
ze.ˈfɾan.ka -50.74279
be.ˈʒan.tɾe -49.19741
ʒa.ˈgɾan.fe -51.86230
me.ˈxes.vɾo -68.84952

[Retour en haut]

Le trapèze vocalique

La fonction plotVowels() génère un trapèze vocalique avec ggplot2. Si l’argument tex = T, la fonction exporte aussi un fichier tex avec le code LaTeX pour créer le même trapèze en utilisant l’extension vowel. Les langues disponibles sont : l’arabe, le français, l’anglais, le néerlandais, l’allemand, le hindi, l’italien, le japonais, le coréen, le mandarin, le portugais, l’espagnol, le swahili, le russe, le talien, le thaï, et le vietnamien. La fonction est aussi disponible comme une appli Shiny ici.

plotVowels(lg = "Spanish", tex = F)
plotVowels(lg = "French", tex = F)

[Retour en haut]

De l’API vers la TIPA

La fonction ipa2tipa() prend une séquence phonémique et renvoie sa séquence tipa équivalente, ce qui peut être utile si vous utilisez \(\LaTeX\).

"Aqui estão algumas palavras" |> 
  cleanText() |> 
  ipa(narrow = T) |> 
  ipa2tipa()
#> Done! Here's your tex code using TIPA:
#> \textipa{ / a."ki es."t\~{a}\~{w} aw."g\~{u}.m5s pa."la.vR5s / }
Output tipa

[Retour en haut]

L’âge dans les études d’acquisition du langage

Il est très commun d’utiliser le format aa;mm pour représenter l’âge des enfants dans les études d’acquisition du langage. Pour faciliter l’analyse de ce type de variable, deux fonctions ont été ajoutées à l’extension : monthsAge(), qui renvoie un âge en mois à partir du format aa;mm, et meanAge(), qui renvoie l’âge moyen dans un vecteur en utilisant le format en question (dans les deux fonctions, vous pouvez spécifier le séparateur année-mois). Voici quelques exemples :

monthsAge(age = "02;06")
#> [1] 30
monthsAge(age = "05:03", sep = ":")
#> [1] 63

meanAge(age = c("02;06", "03;04", NA))
#> [1] "2;11"
meanAge(age = c("05:03", "04:07"), sep = ":")
#> [1] "4:11"

[Retour en haut]

Subvention et remerciements

Une partie de ce projet a bénéficié du programme ENVOL à l’Université Laval. Deux auxiliaires de recherche à l’Université Laval ont travaillé dans la transcription phonémique de l’espagnol et du français (hiver 2023) : Nicolas C. Bustos et Linda Wong.

Citer l’extension

citation("Fonology")
#> To cite Fonology in publications, use:
#> 
#>   Garcia, Guilherme D. (2023). Fonology: Phonological Analysis in R. R
#>   package version 0.9. Available at https://gdgarcia.ca/fonology
#> 
#> A BibTeX entry for LaTeX users is
#> 
#>   @Manual{,
#>     title = {Fonology: Phonological Analysis in {R}},
#>     author = {Guilherme D. Garcia},
#>     note = {R package version 0.9},
#>     year = {2023},
#>     url = {https://gdgarcia.ca/fonology},
#>   }

Copyright © 2024 Guilherme Duarte Garcia

Les références

Clements, G. N. (1990). The role of the sonority cycle in core syllabification. In J. Kingston & M. Beckman (Éds.), Papers in Laboratory Phonology 1: Between the grammar and physics of speech (p. 283‑333). Cambridge University Press.
Garcia, G. D. (2014). Portuguese Stress Lexicon.
Garcia, G. D. (2017a). Weight effects on stress: lexicon and grammar [Thèse de doctorat, McGill University]. https://doi.org/10.31219/osf.io/bt8hk
Garcia, G. D. (2017b). Weight gradience and stress in Portuguese. Phonology, 34(1), 41‑79. https://doi.org/10.1017/S0952675717000033
Garcia, G. D. (2019). When lexical statistics and the grammar conflict: learning and repairing weight effects on stress. Language, 95(4), 612‑641. https://doi.org/10.1353/lan.2019.0068
Garcia, G. D. (2023). Fonology: Phonological Analysis in R. https://gdgarcia.ca/fonology
Parker, S. (2011). Sonority. In M. van Oostendorp, C. J. Ewen, E. Hume, & K. Rice (Éds.), The Blackwell Companion to Phonology (p. 1160‑1184). Wiley Online Library. https://doi.org/10.1002/9781444335262.wbctp0049
Wetzels, W. L. (2007). Primary word stress in Brazilian Portuguese and the weight parameter. Journal of Portuguese Linguistics, 5, 9‑58. https://doi.org/10.5334/jpl.144

Notes de bas de page

  1. Les fonctions sans le suffixe _pt et _sp sont indépendentes de la langue.↩︎