diff --git a/papers/blaine_mooers/banner.png b/papers/blaine_mooers/banner.png new file mode 100644 index 0000000000..e6a793bd6c Binary files /dev/null and b/papers/blaine_mooers/banner.png differ diff --git a/papers/blaine_mooers/images/3speechTo.png b/papers/blaine_mooers/images/3speechTo.png new file mode 100644 index 0000000000..ffa94bbe06 Binary files /dev/null and b/papers/blaine_mooers/images/3speechTo.png differ diff --git a/papers/blaine_mooers/images/AzureCustomModel.png b/papers/blaine_mooers/images/AzureCustomModel.png new file mode 100644 index 0000000000..05f196af27 Binary files /dev/null and b/papers/blaine_mooers/images/AzureCustomModel.png differ diff --git a/papers/blaine_mooers/images/DisplayElectronDensityEquation.png b/papers/blaine_mooers/images/DisplayElectronDensityEquation.png new file mode 100644 index 0000000000..73cdcc6b94 Binary files /dev/null and b/papers/blaine_mooers/images/DisplayElectronDensityEquation.png differ diff --git a/papers/blaine_mooers/images/ForgettingCurve.png b/papers/blaine_mooers/images/ForgettingCurve.png new file mode 100644 index 0000000000..131eede060 Binary files /dev/null and b/papers/blaine_mooers/images/ForgettingCurve.png differ diff --git a/papers/blaine_mooers/images/StatModel.png b/papers/blaine_mooers/images/StatModel.png new file mode 100644 index 0000000000..8dab5d5f34 Binary files /dev/null and b/papers/blaine_mooers/images/StatModel.png differ diff --git a/papers/blaine_mooers/images/VoiceInActivePage.png b/papers/blaine_mooers/images/VoiceInActivePage.png new file mode 100644 index 0000000000..d262cbd763 Binary files /dev/null and b/papers/blaine_mooers/images/VoiceInActivePage.png differ diff --git a/papers/blaine_mooers/images/VoiceInChrome.png b/papers/blaine_mooers/images/VoiceInChrome.png new file mode 100644 index 0000000000..902b2b4a75 Binary files /dev/null and b/papers/blaine_mooers/images/VoiceInChrome.png differ diff --git a/papers/blaine_mooers/images/VoiceInCode1.png b/papers/blaine_mooers/images/VoiceInCode1.png new file mode 100644 index 0000000000..67c7d310b2 Binary files /dev/null and b/papers/blaine_mooers/images/VoiceInCode1.png differ diff --git a/papers/blaine_mooers/images/VoiceInCode2.png b/papers/blaine_mooers/images/VoiceInCode2.png new file mode 100644 index 0000000000..f38c3d4a6a Binary files /dev/null and b/papers/blaine_mooers/images/VoiceInCode2.png differ diff --git a/papers/blaine_mooers/images/VoiceInCommands1.png b/papers/blaine_mooers/images/VoiceInCommands1.png new file mode 100644 index 0000000000..3003653807 Binary files /dev/null and b/papers/blaine_mooers/images/VoiceInCommands1.png differ diff --git a/papers/blaine_mooers/images/VoiceInCommands2.png b/papers/blaine_mooers/images/VoiceInCommands2.png new file mode 100644 index 0000000000..325a6a287a Binary files /dev/null and b/papers/blaine_mooers/images/VoiceInCommands2.png differ diff --git a/papers/blaine_mooers/images/VoiceInCustomCommandsContractions.png b/papers/blaine_mooers/images/VoiceInCustomCommandsContractions.png new file mode 100644 index 0000000000..0115f45f79 Binary files /dev/null and b/papers/blaine_mooers/images/VoiceInCustomCommandsContractions.png differ diff --git a/papers/blaine_mooers/images/VoiceInFilePermission.png b/papers/blaine_mooers/images/VoiceInFilePermission.png new file mode 100644 index 0000000000..bb278f0795 Binary files /dev/null and b/papers/blaine_mooers/images/VoiceInFilePermission.png differ diff --git a/papers/blaine_mooers/images/VoiceInInsertItem.png b/papers/blaine_mooers/images/VoiceInInsertItem.png new file mode 100644 index 0000000000..d11e825d1f Binary files /dev/null and b/papers/blaine_mooers/images/VoiceInInsertItem.png differ diff --git a/papers/blaine_mooers/images/VoiceInLanguages.png b/papers/blaine_mooers/images/VoiceInLanguages.png new file mode 100644 index 0000000000..3f3a2f9087 Binary files /dev/null and b/papers/blaine_mooers/images/VoiceInLanguages.png differ diff --git a/papers/blaine_mooers/images/VoiceInNewSentence.png b/papers/blaine_mooers/images/VoiceInNewSentence.png new file mode 100644 index 0000000000..fe487c0b68 Binary files /dev/null and b/papers/blaine_mooers/images/VoiceInNewSentence.png differ diff --git a/papers/blaine_mooers/images/VoiceInNotepad.png b/papers/blaine_mooers/images/VoiceInNotepad.png new file mode 100644 index 0000000000..1f5d556efe Binary files /dev/null and b/papers/blaine_mooers/images/VoiceInNotepad.png differ diff --git a/papers/blaine_mooers/images/VoiceIncustomCommands.png b/papers/blaine_mooers/images/VoiceIncustomCommands.png new file mode 100644 index 0000000000..6a0bb10b5e Binary files /dev/null and b/papers/blaine_mooers/images/VoiceIncustomCommands.png differ diff --git a/papers/blaine_mooers/images/VoiceIneditVoiceCommand.png b/papers/blaine_mooers/images/VoiceIneditVoiceCommand.png new file mode 100644 index 0000000000..d110659cd6 Binary files /dev/null and b/papers/blaine_mooers/images/VoiceIneditVoiceCommand.png differ diff --git a/papers/blaine_mooers/images/VoiceInsNotepad.png b/papers/blaine_mooers/images/VoiceInsNotepad.png new file mode 100644 index 0000000000..d48002a253 Binary files /dev/null and b/papers/blaine_mooers/images/VoiceInsNotepad.png differ diff --git a/papers/blaine_mooers/images/VoiceIntest-html.png b/papers/blaine_mooers/images/VoiceIntest-html.png new file mode 100644 index 0000000000..8aef926e43 Binary files /dev/null and b/papers/blaine_mooers/images/VoiceIntest-html.png differ diff --git a/papers/blaine_mooers/images/VoiceTypingCommandPage.png b/papers/blaine_mooers/images/VoiceTypingCommandPage.png new file mode 100644 index 0000000000..0f1c368f7d Binary files /dev/null and b/papers/blaine_mooers/images/VoiceTypingCommandPage.png differ diff --git a/papers/blaine_mooers/images/cell4.png b/papers/blaine_mooers/images/cell4.png new file mode 100644 index 0000000000..53d16291e6 Binary files /dev/null and b/papers/blaine_mooers/images/cell4.png differ diff --git a/papers/blaine_mooers/images/csvExampleFile.png b/papers/blaine_mooers/images/csvExampleFile.png new file mode 100644 index 0000000000..07975ce3f5 Binary files /dev/null and b/papers/blaine_mooers/images/csvExampleFile.png differ diff --git a/papers/blaine_mooers/images/howItWorks.png b/papers/blaine_mooers/images/howItWorks.png new file mode 100644 index 0000000000..ca7623116e Binary files /dev/null and b/papers/blaine_mooers/images/howItWorks.png differ diff --git a/papers/blaine_mooers/images/markdown.png b/papers/blaine_mooers/images/markdown.png new file mode 100644 index 0000000000..36e1674462 Binary files /dev/null and b/papers/blaine_mooers/images/markdown.png differ diff --git a/papers/blaine_mooers/images/quiz.png b/papers/blaine_mooers/images/quiz.png new file mode 100644 index 0000000000..f0a6956a19 Binary files /dev/null and b/papers/blaine_mooers/images/quiz.png differ diff --git a/papers/blaine_mooers/images/runningQuiz.png b/papers/blaine_mooers/images/runningQuiz.png new file mode 100644 index 0000000000..efb54873bb Binary files /dev/null and b/papers/blaine_mooers/images/runningQuiz.png differ diff --git a/papers/blaine_mooers/images/startday.png b/papers/blaine_mooers/images/startday.png new file mode 100644 index 0000000000..1dba633315 Binary files /dev/null and b/papers/blaine_mooers/images/startday.png differ diff --git a/papers/blaine_mooers/images/words6.png b/papers/blaine_mooers/images/words6.png new file mode 100644 index 0000000000..0ce47cc5c4 Binary files /dev/null and b/papers/blaine_mooers/images/words6.png differ diff --git a/papers/blaine_mooers/main.md b/papers/blaine_mooers/main.md new file mode 100644 index 0000000000..34bce45899 --- /dev/null +++ b/papers/blaine_mooers/main.md @@ -0,0 +1,432 @@ +--- +# Voice Computing with Python in Jupyter Notebooks +title: Voice Computing with Python in Jupyter Notebooks +abstract: | + Jupyter is a popular platform for writing interactive computational narratives that contain computer code and its output interleaved with prose that describes the code and the output. It is possible to use one's voice to interact with Jupyter notebooks. This capability improves access to those with impaired use of their hands. Voice computing also increases the productivity of workers who are tired of typing and increases the productivity of those workers who speak faster than they can type. Voice computing can be divided into three activities: speech-to-text, speech-to-command, and speech-to-code. We will provide examples of the first two activities with the Voice-In Plus plugin for Google Chrome and Microsoft Edge. To support the editing of Markdown and code cells in Jupyter notebooks, we provide several libraries of voice commands at MooersLab on GitHub. +--- + + +## Introduction + +Voice computing includes speech-to-text, speech-to-commands, and speech-to-code. +These activities enable you to use your voice to generate prose, operate your computer, and write code. +Using your voice can partially replace use of the keyboard when tired of typing, suffering from repetitive stress injuries, or both. +With the Voice In Plus plugin for Google Chrome and Microsoft Edge, we could be productive within an hour. +This plugin is easy to install, provides accurate dictation, and is easy to modify to correct wrong word insertions with text replacements. + +We mapped spoken words to be replaced, called *voice triggers*, to equations set in LaTeX and to code snippets that span one to many lines. +These *voice-triggered snippets* are analogous to traditional tab-triggered snippets supported by most text editors. +(A tab trigger is a placeholder word replaced with the corresponding code when the tab key is pressed after entering the tab trigger. +The existing extensions for code snippets in Jupyter do not support tab triggers.) +We could use Voice In Plus to insert voice-triggered snippets into code and Markdown cells in Jupyter notebooks. +Our voice-triggered snippets still require customizing to the problem at hand via some use of the keyboard, but their insertion by voice command saves time. + +To facilitate voice commands in Jupyter notebooks, we have developed libraries of voice-triggered snippets for use in Markdown or code cells with the *Voice-In Plus* plugin. +We are building on our experience with tab-triggered code snippets in text editors [@Mooers2021TemplatesForWritingPyMOLScripts] and domain-specific code snippet libraries for Jupyter [@Mooers2021APyMOLSnippetLibraryForJupyterToBoostResearcherProductivity]. +We have made libraries of these voice-triggered snippets for several of the popular modules of the scientific computing stack for Python. +These voice-triggered snippets are another tool for software engineering that complements existing tools for enhancing productivity. + + +## Methods and Materials + +### Hardware +We used a 2018 15-inch MacBook Pro laptop computer. +It had 32 gigabytes of RAM and one Radeon Pro 560X 4 GB GPU. +We used the laptop's built-in microphone to record dictation while sitting or standing up to 20 feet (ca. 6 m) away from the computer. + +### Installation of Voice In Plus +We used the *Voice In* plugin provided by Dictanote Inc. +First, we installed the *Voice In* plugin by navigating to the [Plugin In page](https://chromewebstore.google.com/detail/voice-in-speech-to-text-d) in the Google Chrome Web Store on the World Wide Web. +Second, the [Microsoft Edge Addons web site](https://microsoftedge.microsoft.com/addons/Microsoft-Edge-Extensions-Home) was accessed to install the plugin in Microsoft Edge. + +We needed an internet connection to use *Voice In* because Dictanote tracks the websites visited and whether the plugin worked on those websites. +*Voice In* uses the browser's built-in Speech-to-Text software to transcribe speech into text, so no remote servers are used for the transcription,/ so the transcription process was nearly instant and kept up with the dictation of multiple paragraphs. +Dictanote does not store the audio or the transcripts. + +After activating the plugin, we customized it by selecting a dictation language from a pull-down menu. +We selected **English (United States)** from the 15 dialects of English. +The English variants include dialects from Western Europe, Africa, South Asia, and Southeast Asia; many languages other than English are also supported. + +Next, we set a keyboard shortcut to activate the plugin. +We selected command-L on our Mac because this shortcut was not already in use. +A list of Mac shortcuts can be found [here](https://support.apple.com/en-us/102650). +This second customization was the last one that we could make for the free version of *Voice In*. + +Customized text replacements are available in *Voice In Plus*. +*Voice In Plus* is activated by purchasing a $39 annual subscription through the **Subscription** sub-menu in the *Voice In Settings* sidebar of the *Voice In Options* web page. +Monthly and lifetime subscription options are available. +Only one subscription was required to use *Voice In Plus* in both web browsers. +The library is synched between the browsers. + +After purchasing a subscription, we accessed the **Custom Commands** in the *Voice In Settings* sidebar. +We used the **Add Command** button to enter a voice trigger to start a new sentence when writing one sentence per line {ref}`fig:newSentence`. +The custom command for `new paragraph` can include a `period` followed by two `new line` commands, which works well when writing with blank lines between paragraphs and without indentation. + +:::{figure} ./images/VoiceInNewSentence.png +:label: fig:newSentence +:width: 50% +Entering a single voice trigger and the corresponding command in Voice In Plus. +::: + +The phrases making up these voice triggers will no longer be available during dictation because they will be used to trigger text replacements. +It is best to pick as voice triggers phrases that are unlikely to be spoken during dictation. + +We kept the voice triggers as short as possible to ease accurate recall of the voice triggers. +We had trouble correctly recalling voice triggers longer than four or five words. +Three-word voice triggers are a good compromise between specificity and success at recall. + +:::{figure} ./images/csvexamplefile.png +:label: fig:csvexamplefile +:width: 50% +Snapshot of CSV file on Github for the [*jupyter-voice-in*](https://github.com/MooersLab/jupyter-voice-in/blob/main/jupyter.csv) library. +::: + +An exception to this guideline for shorter voice triggers was using two to three words at the beginning of a set of voice triggers to group them in the online *Voice In* library. +Grouping related voice commands made it easier to find them in the online library. +For example, all Jupyter-related line magic voice triggers start with the phrase *line magic*. +The prefix *line magic* is easy to remember, so it only adds a little to the recall problem. +We show below a snapshot of the CSV file displayed in a pleasant format on GithHub for the Jupyter line magics {ref}`fig:csvexamplefile`. +Note that these CSV files are atypical because they do not contain a line of column headers; *Voice In* does not recognize column headings. + +The accuracy of interpretation of the phrase by the software was another limitation. +We would replace frequently misinterpreted words with other words that were more often correctly interpreted. + +We had to take care not to make voice triggers that were embedded in longer voice triggers to avoid unintended text replacements. +For example, when we found a two-word phrase starting a four-word phrase, we would extend the two-word phrase to three words by selecting a third word that would break the overlap between the two voice triggers. +Otherwise, the two-word phrase would trigger a text replacement that was different from the text replacement that was expected from the four-word phrase. + +We used the **Bulk Add** button to upload multiple commands from a two-column CSV file with commas as the field sepearator. +The file contents were selected and pasted in a text box that is opened upon clicking on the **Bulk Add** button. +The voice-triggers reside in the left column, and the text replacements reside in the right column. +Any capitalization in the voice trigger was ignored by the software. + +Multiline text replacements could be handled in one of two ways. +First, all of the text could be placed on a single line and the built-in command `` could be inserted in this line where linebreaks were needed. +Second, the multiline text could be enclosed by one set of double quotes enclosing the multiline block of text. +Internal double quotes in these text block had to be replaced with single quotes. +It was not possible to use a backspace to escape internal pre-existing double quotation marks. + +Text replacements consisting of commas also had to be enclosed with double else the commas would be misintrepreted as field separators. +This also appled on Python code that contained commas. + +The formatting of the text replacement was controlled by inserting built-in *Voice In Plus* commands enclosed in angle brackets. +To ensure that the first letter of a line Python code was not capitalized, we used the built-in command `` before the Python code: (e.g., `python import numpy,import numpy as np`). +The command in angle brackets would be applied during insertion of the text replacement, but it would appear in inserted code. + +The transcription of the spoken words appear momentarily in a transitory transcript that hovers about the text box. +We mapped the misinterpreted words to the desired text replacement. +For example, we mapped `open syfy` to `` to open the webpage for the schedule of SciPy 2024 when we said, "open SciPy 2024". + +The **Export** button opened a text box with the custom commands in CSV file format. +All the contents of the text box were selected, copied, and pasted into a local CSV file using either the text editor TextMate or Emacs version 29.3. +The **Synch** button was used to synchronize devices. + +A GUI shows all the voice triggers and their text replacements immediately below the row of buttons just mentioned above. +Each row in the GUI has an edit icon and a delete icon. +The edit icon opens a pop-up menu similar to the pop-up menu invoked by the **Add Command** button. + +### Construction of the snippet libraries +Some of our voice snippets had already been used for a year to compose prose using dictation. +These snippets are in modular CSV files to ease their selective use. +The contents of these files can be copied and pasted into the `bulk add` text area of the Voice In Plus configuration GUI. + +### Construction of interactive quizzes +We developed interactive quizzes to aid the mastery of the *Voice In Plus* syntax. +We wrote the quiz as a Python script that can run in the terminal or in Jupyter notebooks. +We stored each question, answer, and explanation triple in a tuple because tuples are immutable. +We stored the tuples in a list because lists are sortable. +The quiz randomizes the order of the questions upon restart, ensuring a fresh and challenging experience every time. +When you fail to answer a question correctly, the quiz provides feedback, giving you the opportunity to learn from your mistakes and improve. +Recycling the wrongly answered questions builds the recall of the correct answers. +The number of questions in a quiz was limited to 40 to avoid exhausting the user. + +### Availability of the libraries and quizzes +We tested the libraries using Jupyter Lab version 4.2 and Python 3.12 installed from MacPorts. +All libraries are available at MooersLab on GitHub for download. + +## Results + +First, we describe the contents of the snippet libraries and the kinds of problems they solve. +We group the libraries into several categories to simplify their explanation. +Second, we describe the deployment of the snippet libraries for Voice In Plus (VIP). + +### Composition of the libraries + +Our descriptions of these libraries include examples to illustrate how voice-triggered snippets work with automated speech recognition software. +Developers can leverage our libraries in two ways: by enhancing them with their unique commands or by using them as blueprints to create libraries from scratch. + +The libraries are made available in a modular format so the user can select the most valuable commands for their workflow. +In general, our libraries are broad in scope, so they meet the needs of most users. +Several libraries are domain-specific. +These domain-specific libraries serve as a catalyst for the creation of libraries tailored to other fields, sparking innovation, and expanding the reach of voice-triggered snippets. + +We divided the contents of the libraries into two categories. +One subset of libraries supports dictating about science in the Markdown cells of Jupyter notebooks, while the other subset supports writing scientific Python in code cells. +These voice-triggered snippets can also be applied to Markdown and code cells in Colab Notebooks. +While some code, such as IPython line and cell magics, is specific to Jupyter, most of the voice-triggered snippets can be used in Markdown files and Python scripts being edited in Jupyter Lab. + +Likewise, these snippets can be used in other browser-hosted text editors such as the new web version of Visual Studio Code. +This is because Voice In Plus works in most text areas of web browsers. +This means that the ample text area like that found in Write Honey website site can be used to draft documents and Python scripts with the aid of Voice In Plus snippets. +The code or text be directly edited by an advanced text editor by using the GhostText plugin to connect the web-based text area to a text editor. +Alternately, the draft document or script can be copied and saved to a file that is imported into Jupyter Lab for further editing. + +### Libraries for Markdown cells + +These libraries contain a short phrase paired with its replacement: another phrase or a chunk of computer code. +In analogy to a tab trigger in text editors, we call the first short phrase a voice trigger. +Tab triggers are initiated by typing, followed by the tab key, which inserts the corresponding snippet of code. +Some text editors can autocomplete the tab-trigger name, so these text editors require two tab key entries. +The first tab auto-completes the tab-trigger name. +Then, the second tab leads to the insertion of the corresponding code. +This two-step process of tab triggers empowers users with the flexibility to select a different tab trigger before inserting the code, enhancing the customization potential of text editors. +It is important to note that voice triggers, while efficient, do not allow for the revision of the voice trigger. +In the event of an incorrect code insertion, the undo command must be used, underscoring the need for caution when selecting voice triggers. + +The most straightforward text replacements involved the replacement of English contractions with their expansions {ref}`fig:contractions`. +Science writers do not use English contractions in formal writing for many reasons. +Many automatic speech recognition software packages will default to using contractions because the software's audience is people who write informally for social media, where English contractions are acceptable. +By adding the library that maps contractions to their expansions, the expansion will be inserted whenever the contraction is used otherwise. +This automated replacement of English contractions saves time during the editing process. + +:::{figure} ./images/VoiceInCustomCommandsContractions.png +:alt: contractions +:width: 60% +:align: center +:label: fig:contractions + +Webpage of custom commands. The buttons are used to edit existing commands and add new commands. Three English contractions and their expansions are shown. +::: + +We grouped the voice triggers by the first word of the voice trigger {ref}`table:commands`. +This first word is often a verb. +For instance, the word `expand' is used before an acronym that will be replaced with its expansion. +Your memory of the words represented by the letters in the acronym often needs to be accurate. +The library ensures that you use the correct expansion of the acronym. +By providing instant access to the correct acronym expansions, the library significantly reduces the time that would otherwise be spent on manual lookups, allowing you to focus on your work. +We have included acronyms widely used in Python programming, scientific computing, data science, statistics, machine learning, and Bayesian data analysis. +These commands are found in domain-specific libraries, so users can select which voice triggers to add to their private collection of voice commands. + +The customized commands are listed in the Voice-In Plus GUI in alphabetical order with one command and its corresponding text replacement per row. +The prefixes group like commands. +This eases the manual look up of the commands. + +Some prefixes are two or more words long. +For example, the compound preflx *insert Python* aids grouping of code by programming language. + +:::{table} Examples of voice commands with the prefix in bold that is used to group commands. +:label: table:commands +:align: center + +| Voice commands | +|:-------------------------------------------------------------------------------------------------------------------| +| **expand** acronyms | +| **the book** title | +| **email** inserts list of e-mail addresses (e.g., email bayesian study group) | +| **insert Python** (e.g., insert Python for horizontal bar plot) | +| **insert Markdown** (e.g., insert Markdown header 3) | +| **list** (e.g., list font sizes in beamer slides.) | +| **open** webpage (e.g., open google scholar) | +| **display** insert equation in display mode (e.g., display electron density equation) | +| **display with terms** above plus list of terms and their definitions (e.g., display electron density equation) | +| **inline** equation in-line (e.g., inline information entropy) | +| **site** insert corresponding citekey (e.g., site Jaynes 1957) | +:::: + + +Another example of a verb starting a voice trigger is the command `display `. +This command is used in Markdown cells to insert equations in the display mode of LaTeX in Markdown cells. +For instance, the voice trigger `display the electron density equation` is a testament to the convenience of our system, as shown in the transcript of a Zoom video {ref}`fig:displayeq`. +The image in the middle shows the text replacement as a LaTeX equation in the display mode. +This image is followed by the resulting Markdown cell after rendering by running the cell. + +:::{figure} ./images/DisplayElectronDensityEquation.png +:alt: display +:width: 100% +:align: center +:label: fig:displayeq + +Three snapshots from a Zoom video of using the voice-trigger *display electron density equation* in a Markdown cell in a Jupyter notebook. A. The Zoom transcript showing the spoken voice trigger. B. The text replacement in the form of a math equation written in LaTeX in display mode in the Markdown cell. C. The rendered Markdown cell. The green and black tab on the right of each panel indicates that the Voice In plugin is active and listening for speech. +::: + + +Likewise, the command `inline ` is used to insert equations in prose sections in Markdown cells. +We have introduced voice-triggered snippet libraries for equations commonly used in machine learning and Bayesian data analysis https://github.com/MooersLab/. +These equations can also be used a templates to generate new equations. +While the development of libraries are still in progress, they serve as flexible templates that can be adapted for any specific domain. + +Some voice triggers start with a noun. +For example, the voice trigger `URL` is used to insert URLs for essential websites. + +Another example involves using the verb `list` in the voice trigger, as in `list matplotlib color codes`, to generate a list of the color codes used in Matplotlib plots. +These voice triggers provide instant access to essential information, saving you the time and effort of manual searches. + +The markup language code is inserted using the verb *insert*, followed by the markup language name and the name of the code. +For example, the command `insert markdown itemized list` will insert five vertically aligned dashes to start an itemized list. +The command `insert latex itemized list` will insert the corresponding code for an itemized list in LaTeX. + +We have developed a library specifically for the flavor of [Markdown](https://github.com/MooersLab/markdown-jupyter-voice-in/blob/main/markdown.csv) utilized in Jupyter notebooks. +This library is used to insert the appropriate Markdown code in Markdown cells. +We have included a [library for LaTeX](https://github.com/MooersLab/latex-voice-in) because Jupyter Lab can edit tex files. + +We have not figured out how to use voice commands to advance the cursor in a single step to sites where edits should be made, analogous to tab stops in conventional snippets. +Instead, the built-in voice commands can move the cursor forward or backward and select replacement words. +We included the markup associated with the yasnippet snippet libraries to serve as a benchmark for users to recognize the sites that should be considered for modification to customize the snippet for their purpose. + + +### Libraries for code cells + +The `insert` command in code-cell libraries allows the insertion of chunks of Python code, enhancing your data science workflow. +We avoid making voice commands for small code fragments that might fit on a single line. +An exception to this was the inclusion of a collection of one-liners in the form of several kinds of comprehensions. +As mentioned, we have developed practical chunks of code designed to perform specific functions, making your data analysis tasks more efficient. +These chunks of code are functions that produce an output item, such as a table or plot. +The idea was to fill a code cell with the code required to produce the desired output. +Unfortunately, the user will still have to use the computer mouse to move the cursor back over the code chunk and customize portions of the code chunk as required. + +While self-contained examples that utilize generated data can illustrate concepts, these examples are frustrating for beginners who need to read actual data and would like to apply the code example to their problem. +Reading appropriately cleaned data is a common task in data science and a common barrier to applying Jupyter notebooks to scientific problems. +Our data wrangling library provides code fragments that directly import various file types, easing the task of data import and allowing focus on downstream utilization and analysis. + +After the data are verified as correctly imported, exploring them by plotting them to detect relationships between a model's parameters and the output is often necessary. +Our focus on the versatile *matplotlib* library, which generates various plots, is designed to inspire creativity in data visualization and analysis [*matplotlib]. +Our code fragments cover the most commonly used plots, such as scatter plots, bar graphs (including horizontal bar graphs), kernel density fitted distributions, heat Maps, pie charts, and contour plots. +We include a variety of examples for formatting tick marks and axis labels as well as the keys and the form of the lines so users can use this information as templates to generate plots for their purposes. +Generating plots with lines of different shapes, whether solid, dashed, dotted, or combinations thereof, is essential because plots generated with just color are vulnerable to having their information compromised when printed in grayscale. +Although we provide some examples from higher-order plotting programs like *seaborn* [@seaborn], we focused on matplotlib because most other plotting programs, except the interactive plotting programs, are built on top of it. + +We also support the import of external images. +These are often overlooked, but these externally derived images are often essential parts of the story the Jupyter notebook is telling. + + +### Jupyter specific library + +We provide a [library](https://github.com/MooersLab/jupyter-voice-in/blob/main/jupyter.csv) of 85 cell and line magics that facilitate the Jupyter notebook's interaction with the rest of the operating system. +Our cell magics, easily identifiable by their cell magic prefix, and line magics, with the straightforward line magic prefix, are designed to make the Jupyter notebook experience more intuitive. +For example, the voice command *line majic run* inserts `%run`; it is used to run script files after supplying the name of the script file as also shown in {ref}`fig:quiz`. + + +### Interactive quiz + +We developed a [quiz](https://github.com/MooersLab/voice-in-basics-quiz) to improve recall of the voice commands. +These quizzes are interactive and can be run in the terminal or in Jupyter notebooks {ref}`fig:quiz`. +The latter can store a record of your performance on a quiz. + +:::{figure} ./images/runningQuiz.png +:label: fig:quiz +:width: 130% +An example of an interactive session with a quiz in a Jupyter notebook. The code for running the quiz was inserted into the code cell with the voice command `run voice in quiz`. The quiz covers a range of voice commands, including [specific voice commands covered in the quiz]. +::: + +To build long-term recall of the commands, you must take the quiz five or more times on alternate days, according to the principles of spaced repetition learning. +These principles were developed by the German psychologist Hermann Ebbinghaus near the end of the 19th Centur and popularized in English his 1913 book *Memory: A Contribution to Experimental Psychology*. +They have been validated several times by other researchers, including those developed an alogorithm for optimizing the spacing of the repetitions as function of the probability of recall [@tabibian2019enhancinghumanlearningviaspacedrepetitionoptimization]. +Spaced repetition learning is one of the most firmly established results of research into human psychology. + +Most people need discipline to carry out this kind of learning because they have to schedule the time to do the follow-up sessions. +Instead, people will find it more convenient to take these quizzes several times in 20 minutes before they spend many hours utilizing the commands. +If that use occurs on subsequent days, then recall will be reinforced, and retaking the quiz may not be necessary. + + +### Limitations on using Voice In Plus + +The plugin operates in text areas on thousands of web pages. +These text areas include those of web-based email software and online sites that support distraction-free writing like [Write Honey](https://app.writehoney.com). +These text areas also include the Markdown and code cells of Jupyter notebooks and other web-based computational notebooks such as Colab Notebooks. +Voice In also works in plain text documents opened in Jupyter Lab for online writing. + +Voice In works in Jupyter Lite. +It also works in streamlit-quill, which uses a python script to generate a text box in the default web browser. +It also works in the web-based version of [VS Code](https://vscode.dev/). + +Voice In will not work in desktop applications that support the editing of Jupyter notebooks, such as the [*JupyterLab Desktop*](https://github.com/jupyterlab/jupyterlab-desktop) application, the [*nteract*](https://nteract.io/) application, and external text editors, such as *VS Code*, that support the editing of Jupyter notebooks. +Likewise, *Voice In Plus* will not work in Python Widgets. +*Voice In Plus* is limited to web browsers, whereas other automated speech recognition software can also operate in the terminal and at the command prompt in GUI-driven applications. + +*Voice In Plus* is very accurate with a word error rate that is well below 10\%. +Like all other dictation software, the word error rate depends on the quality of the microphone using used. +*Voice-In Plus* can pick out words from among background ambient noise such as load ventilation systems, traffic, and outdoor bird songs. + +The language model used by *Voice-In Plus* is quite robust in that dictation can be performed without an external microphone. +We found no reduction in word error rate when using a high-quality Yeti external microphone. +Our experience might be a reflection of our high-end hardware and may not transfer to low-end computers. + +Because of the way *Voice-In Plus* is set up to utilize the Speech-to-Text feature of the Google API, there is not much of a latency issue. +The spoken words' transcriptions occur nearly in real-time; there is only a minor lag. +*Voice In Plus* will listen for words for 3 minutes before automatically shutting down. +*Voice In Plus* can generally keep up with dictation occurring at a moderate pace for at least several paragraphs, whereas competing dictation software packages tend to quit after one paragraph. +The program hallucinates when the dictation has occurred at high speed because the transcription has fallen behind. +You have to pay attention to the progress of the transcription if you want all of your spoken words captured. + +If the transcription halts, it is best to deactivate the plugin, activate it, and resume the dictation. +Great care must be taken to pronounce the first word of the sentence loudly so that it will be recorded; otherwise, this first word will likely not be recorded. +This problem of omitted words is most acute when there has been a pause in the dictation. + +The software does not automatically insert punctuation marks. +You have to vocalize the name of the punctuation mark where it is required. +You also have to utilize the built-in new-line command to start new lines. +We have combined the period command with the new line command to create a new command with the voice trigger of `new sentence`. + +You have to develop the habit of using this command if you like to write one sentence per line. +This latter form of writing is very useful for first drafts because it greatly eases the shuffling of sentences in a text editor during rewriting. +This form of writing is also very compatible with version control systems like git because the changes can be tracked by line number. + +The practical limit of on the number of commands is set by the trouble you are willing to tolerate in scrolling up and down the list of commands. +We had an easy time scrolling through a library of about 8,000 commands, and a hard time with a library of about 19,000 commands. +Bulk deletion of selected commands required the assistance from the user support at Dictanote Inc. +They removed our bloated library, and we used the **bulk add** button in the GUI to upload a smaller version of our library. + +## Discussion + +The following four discussion points can enhance understanding the use of *Voice-In Plus* with Jupyter. + +### Independence from breaking changes in Jupyter + +The Jupyter project lacks built-in support for libraries of code snippets. +The development of third-party extensions is a necessity to support the use of code snippets. +Unfortunately, changes in the core of Jupyter occasionally break these third-party extensions. +Users have to create Python environments for older versions of Jupyter to work with their outdated snippet extension while missing out on the new features of Jupyter. +An obvious solution to this problem would be for the Jupyter developers to incorporate one of the snippet extensions into the base distribution of Jupyter to ensure that at least one form of support for snippets is always available. +Using voice-triggered snippets external to Jupyter side steps the disruption of snippet extensions by breaking changes in new versions of Jupyter. + +### Voice-triggered snippets can complement AI-assisted voice computing + +The use of voice-triggered snippets requires knowledge of the code that you want to insert. +The act of acquiring this knowledge is the up-front cost that the user pays to gain access to quickly inserted code snippets that work. +In contrast, AI coding assistants can find code that you do not know about to solve the problem described in your prompt. +From personal experence, the retrieval of the correct code can take multiple iterations of refining the prompt. +Expert prompt engineers will find the correct code in several minutes while beginners may take much longer. +An area of future research is to use AI assistants that have large language models indexed on snipppet libraries to retrieve the correct voice-triggered snippet. + +### Comparision with automated speech recogination extensions for Jupyter lab + +We found three extensions developed for Jupyter Lab that enable speech recognition in Jupyter notebooks. +The first, [jupyterlab-voice-control](https://github.com/krassowski/jupyterlab-voice-control), supports custom commands and relies on the browser's language model. +This extension is experimental; it does not work with Jupyter 4.2. +The second extension, [jupyter-voice-comments](https://github.com/Banpan-Jupyter-Extensions/jupyter-voice-comments), relies on the DaVinci large language model to make comments in Markdown cells and request code fragments. +This program requires clicking on a microphone icon frequently, which makes the user vulnerable to repetitive stress injuries. +The third extension is [jupyter-voicepilot](https://github.com/JovanVeljanoski/jupyter-voicepilot). +Although the extension's name suggests it uses GitHub's Copilot, it uses whisper-1 and ChatGPT3. +This extension requires an API key for ChatGPT3. +The robustness of our approach is that the *Voice-In Plus* should work in all browser-based versions of Jupyter Lab and Jupyter Notebook. + +### Coping with the imperfections of the language model + +One aspect of speech-to-text that it is important to bring up is persistent errors in transcription. +These persistent errors may be due to the language model having difficulties interpreting your speech. +For example, the language model often misinterprets the word *write* as *right*'. +Likewise, the letter *R* is frequently returned as *are* or *our*'. +The remedy for these situations is to map the misinterpreted phrase to the intended phrase. + +This remedy might be the best that can be done for those users who are from a country that is not represented by the selection of English dialects available in Voice In Plus. +People originating from Eastern Europe, Middle East, and northeast Asia fall into this category. +Users in this situation may have to add several hundred text replacements. +As the customized library of text replacements grows, the frequency of wrong word insertions should deline rapidly. + + +### Future directions + +One future direction is to build out the libraries of voice-triggered snippets that have been developed. +Another direction includes the development of voice stops analogous to tab stops in code snippets for advanced text editors. +These voice stops would advance the cursor to all sites that should be considered for editing to customize the code snippet for the problem. +The other related advance would be the mirroring of the parameter values at identical voice stops in analogy to mirrored tab stops in conventional snippets. diff --git a/papers/blaine_mooers/mybib.bib b/papers/blaine_mooers/mybib.bib new file mode 100644 index 0000000000..fb5f0e53e9 --- /dev/null +++ b/papers/blaine_mooers/mybib.bib @@ -0,0 +1,318 @@ +# Feel free to delete these first few references, which are specific to the template: + +# Jupyter related + +@Article{Basu2017ReproducibleResearchWithJupyterNotebooks, + author = {Basu, Arindam}, + title = {Reproducible research with jupyter notebooks}, + doi = {10.22541/au.151460905.57485984}, + url = {https://www.authorea.com/doi/full/10.22541/au.151460905.57485984}, + journal = {Authorea Preprints}, + keywords = {Jupyter, literate programming}, + publisher = {Authorea}, + year = {2017}, +} + +@Article{Dedehayir2016TheHypeCycleModelAReviewAndFutureDirections, + author = {Dedehayir, Ozgur and Steinert, Martin}, + title = {The hype cycle model: A review and future directions}, + pages = {28--41}, + volume = {108}, + file = {:Dedehayir2016TheHypeCycleModelAReviewAndFutureDirections.pdf:PDF}, + journal = {Technological Forecasting and Social Change}, + keywords = {Gartner hype cycle}, + publisher = {Elsevier}, + year = {2016}, + doi = {http://dx.doi.org/10.1016/j.techfore.2016.04.005}, +} + + +@misc{Dictanote2024VoiceIn, + Author = {{Dictanote Inc.}}, + title = {Voice In Plus}, + url = {https://support.dictanote.co/}, + note = {version 4.10}, + year = {2024}, + month ={Aug}, +} + + +@Article{Mooers2021TemplatesForWritingPyMOLScripts, + author = {Mooers, Blaine HM and Brown, Marina E}, + journal = {Protein Science}, + title = {Templates for writing PyMOL scripts}, + year = {2021}, + number = {1}, + pages = {262--269}, + volume = {30}, + annote = {I need to add some text.}, + doi = {10.1002/pro.3997}, + publisher = {Wiley Online Library}, + related = {Mooers2016SimplifyingAndEnhancingTheUseOfPyMOLWithHorizontalScripts,Mooers2020ShortcutsForFasterImageCreationInPyMOL}, + url = {https://onlinelibrary.wiley.com/doi/full/10.1002/pro.3997} +} + + +@Article{Mooers2021APyMOLSnippetLibraryForJupyterToBoostResearcherProductivity, + author = {Mooers, Blaine HM}, + title = {A PyMOL snippet library for Jupyter to boost researcher productivity}, + doi = {10.1109/MCSE.2021.3059536}, + number = {2}, + pages = {47-53}, + volume = {23}, + annote = {Introduces the jupyterlabpymolpysnips library. I gave a talk at JupyterCon 2020 about this topic. I was then invited by Hans Fanghor to submit a paper about it. The organizer of the meeting of Lorena Barba. She was also editor in chief of this journal.}, + file = {:Mooers2021APyMOLSnippetLibraryForJupyterToBoostResearcherProductivity.pdf:PDF}, + journal = {Computing in Science \& Engineering}, + keywords = {Jupyter, literate programming}, + publisher = {IEEE}, + related = {Mooers2021}, + year = {2021}, +} + +@InProceedings{Mooers2023BiomolecularCrystallographicComputingWithJupyter, + author = {{B}laine {H}. {M}. {M}ooers}, + booktitle = {{P}roceedings of the 22nd {P}ython in {S}cience {C}onference}, + title = {{B}iomolecular {C}rystallographic {C}omputing with {J}upyter}, + doi = {10.25080/gerudo-f2bc6f59-004}, + editor = {{M}eghann {A}garwal and {C}hris {C}alloway and {D}illon {N}iederhut}, + pages = {32 - 39}, + publisher = {Oxford University Press}, + file = {:Mooers2023BiomolecularCrystallographicComputingWithJupyter.pdf:PDF}, + keywords = {Jupyter, literate programming}, + year = {2023}, +} + + +@Article{Perez2015ProjectJupyterComputationalNarrativesAsTheEngineOfCollaborativeDataScience, + author = {Fernando Perez and Brian E. Granger and Perez, Fernando and Granger, Brian E}, + title = {Project Jupyter: Computational narratives as the engine of collaborative data science}, + number = {207}, + pages = {108}, + volume = {11}, + annote = {I need to read this.}, + journal = {Retrieved September}, + keywords = {Jupyter, literate programming}, + publisher = {Oxford University Press}, + year = {2015}, +} + + +@Article{Perkel2021TenComputerCodesThatTransformedScience, + author = {Perkel, Jeffrey M}, + title = {Ten computer codes that transformed science.}, + doi = {10.1038/d41586-021-00075-2}, + number = {7842}, + pages = {344--349}, + volume = {589}, + annote = {A survery of sceintists, the nature editors found that Jupyter ranked number three of 10 computer codes that had the biggest impact on their work. I learned about this article in a talk by Fernando Perez at JupyterCon 2023.}, + file = {:Perkel2021TenComputerCodesThatTransformedScience.pdf:PDF}, + journal = {Nature}, + keywords = {Jupyter notebook, IPython notebook, transformative computer codes, Jupyter, literate programming}, + publisher = {Nature Publishing Group}, + year = {2021}, +} + + +@Article{Perez2018SimulationsMeetMachineLearningInStructuralBiology, + author = {P{\'e}rez, Adri{\`a} and Mart{\'\i}nez-Rosell, Gerard and De Fabritiis, Gianni}, + title = {Simulations meet machine learning in structural biology}, + journal = {Current opinion in structural biology}, + year = {2018}, + volume = {49}, + pages = {139--144}, + publisher = {Elsevier} +} + + +@Article{Randles2017UsingTheJupyterNotebookAsAToolForOpenScienceAnEmpiricalStudy, + author = {Bernadette M. Randles and Irene V. Pasquetto and Milena S. Golshan and C. Borgman}, + title = {Using the Jupyter Notebook as a Tool for Open Science: An Empirical Study}, + doi = {10.1109/jcdl.2017.7991618}, + pages = {1-2}, + file = {:Randles2017UsingTheJupyterNotebookAsAToolForOpenScienceAnEmpiricalStudy.pdf:PDF}, + journal = {2017 ACM/IEEE Joint Conference on Digital Libraries (JCDL)}, + keywords = {Jupyter, literate programming}, + publisher = {Oxford University Press}, + year = {2017}, +} + + + +@Book{Reitz2016TheHitchhikersGuideToPythonBestPracticesForDevelopment, + author = {Reitz, Kenneth and Schlusser, Tanya}, + title = {The Hitchhiker's guide to Python: best practices for development}, + publisher = {" O'Reilly Media, Inc."}, + annote = {This is the nuts-and-bolts of software engineering a Python project. It even has a chapter on Jupyter Notebooks.}, + keywords = {Jupyter, literate programming}, + year = {2016}, +} + + +@Article{Smith2016TeachingComputerScienceToBiologistsAndChemistsUsingJupyterNotebooksTutorialPresentation, + author = {Smith, Adam A.}, + title = {Teaching Computer Science to Biologists and Chemists, Using Jupyter Notebooks: Tutorial Presentation}, + doi = {10.5555/3007225.3007252}, + issn = {1937-4771}, + number = {1}, + pages = {126–128}, + volume = {32}, + abstract = {In this tutorial we will discuss teaching basic computer science skills to natural science majors (primarily biologists and chemists). I have spent the last year developing such a course at the University of Puget Sound. CSCI 141: Programming for Natural Scientists is a reformulation of a more typical Introduction to Computer Science class, but aimed at natural scientists rather than computer science and math majors. Offering a class such as this has many benefits for a computer science department:}, + address = {Evansville, IN, USA}, + issue_date = {October 2016}, + journal = {J. Comput. Sci. Coll.}, + keywords = {Jupyter, literate programming}, + month = oct, + numpages = {3}, + publisher = {Consortium for Computing Sciences in Colleges}, + year = {2016}, +} + + +@Book{Sweigart2015AutomateTheBoringStuffWithPythonPracticalProgrammingForTotalBeginners, + title = {Automate the boring stuff with Python: practical programming for total beginners}, + publisher = {No Starch Press}, + year = {2015}, + author = {Sweigart, Al}, + annote = {Chapters of this book are available on-line in html. The book is available in the Metro Library.} +} + + +@InProceedings{Thomas2017TowardInteractiveSupercomputingAtNERSCWithJupyter, + author = {Thomas, Rollin and Canon, Shane and Cholia, Shreyas and Gerhardt, Lisa and Racah, Evan}, + booktitle = {Cray User Group (CUG) Conference Proceedings}, + title = {Toward interactive supercomputing at NERSC with Jupyter}, + organization = {Cray User Group (CUG)}, + publisher = {Oxford University Press}, + annote = {I need to read this.}, + keywords = {Jupyter, literate programming}, + year = {2017}, +} + +@Book{Toomey2017JupyterForDataScienceExploratoryAnalysisStatisticalModelingMachineLearningAndDataVisualizationWithJupyter, + author = {Toomey, Dan}, + title = {Jupyter for data science: Exploratory analysis, statistical modeling, machine learning, and data visualization with Jupyter}, + publisher = {Packt Publishing Ltd}, + keywords = {Jupyter, literate programming}, + year = {2017}, +} + + +# These references may be helpful: + +@inproceedings{jupyter, + abstract = {It is increasingly necessary for researchers in all fields to write computer code, and in order to reproduce research results, it is important that this code is published. We present Jupyter notebooks, a document format for publishing code, results and explanations in a form that is both readable and executable. We discuss various tools and use cases for notebook documents.}, + author = {Kluyver, Thomas and Ragan-Kelley, Benjamin and Pérez, Fernando and Granger, Brian and Bussonnier, Matthias and Frederic, Jonathan and Kelley, Kyle and Hamrick, Jessica and Grout, Jason and Corlay, Sylvain and Ivanov, Paul and Avila, Damián and Abdalla, Safia and Willing, Carol and {Jupyter development team}}, + editor = {Loizides, Fernando and Scmidt, Birgit}, + location = {Netherlands}, + publisher = {IOS Press}, + url = {https://eprints.soton.ac.uk/403913/}, + booktitle = {Positioning and Power in Academic Publishing: Players, Agents and Agendas}, + year = {2016}, + pages = {87--90}, + title = {Jupyter Notebooks - a publishing format for reproducible computational workflows}, +} + +@article{matplotlib, + abstract = {Matplotlib is a 2D graphics package used for Python for application development, interactive scripting, and publication-quality image generation across user interfaces and operating systems.}, + author = {Hunter, J. D.}, + publisher = {IEEE COMPUTER SOC}, + year = {2007}, + doi = {https://doi.org/10.1109/MCSE.2007.55}, + journal = {Computing in Science \& Engineering}, + number = {3}, + pages = {90--95}, + title = {Matplotlib: A 2D graphics environment}, + volume = {9}, +} + +@article{numpy, + author = {Harris, Charles R. and Millman, K. Jarrod and van der Walt, Stéfan J. and Gommers, Ralf and Virtanen, Pauli and Cournapeau, David and Wieser, Eric and Taylor, Julian and Berg, Sebastian and Smith, Nathaniel J. and Kern, Robert and Picus, Matti and Hoyer, Stephan and van Kerkwijk, Marten H. and Brett, Matthew and Haldane, Allan and del Río, Jaime Fernández and Wiebe, Mark and Peterson, Pearu and Gérard-Marchant, Pierre and Sheppard, Kevin and Reddy, Tyler and Weckesser, Warren and Abbasi, Hameer and Gohlke, Christoph and Oliphant, Travis E.}, + publisher = {Springer Science and Business Media {LLC}}, + doi = {https://doi.org/10.1038/s41586-020-2649-2}, + date = {2020-09}, + year = {2020}, + journal = {Nature}, + number = {7825}, + pages = {357--362}, + title = {Array programming with {NumPy}}, + volume = {585}, +} + +@misc{pandas1, + author = {{The Pandas Development Team}}, + title = {pandas-dev/pandas: Pandas}, + month = feb, + year = {2020}, + publisher = {Zenodo}, + version = {latest}, + url = {https://doi.org/10.5281/zenodo.3509134}, +} + +@inproceedings{pandas2, + author = {Wes McKinney}, + title = {{D}ata {S}tructures for {S}tatistical {C}omputing in {P}ython}, + booktitle = {{P}roceedings of the 9th {P}ython in {S}cience {C}onference}, + pages = {56 - 61}, + year = {2010}, + editor = {{S}t\'efan van der {W}alt and {J}arrod {M}illman}, + doi = {https://doi.org/10.25080/Majora-92bf1922-00a}, +} + +@article{scipy, + author = {Virtanen, Pauli and Gommers, Ralf and Oliphant, Travis E. and + Haberland, Matt and Reddy, Tyler and Cournapeau, David and + Burovski, Evgeni and Peterson, Pearu and Weckesser, Warren and + Bright, Jonathan and {van der Walt}, St{\'e}fan J. and + Brett, Matthew and Wilson, Joshua and Millman, K. Jarrod and + Mayorov, Nikolay and Nelson, Andrew R. J. and Jones, Eric and + Kern, Robert and Larson, Eric and Carey, C J and + Polat, {\.I}lhan and Feng, Yu and Moore, Eric W. and + {VanderPlas}, Jake and Laxalde, Denis and Perktold, Josef and + Cimrman, Robert and Henriksen, Ian and Quintero, E. A. and + Harris, Charles R. and Archibald, Anne M. and + Ribeiro, Ant{\^o}nio H. and Pedregosa, Fabian and + {van Mulbregt}, Paul and {SciPy 1.0 Contributors}}, + title = {{{SciPy} 1.0: Fundamental Algorithms for Scientific + Computing in Python}}, + journal = {Nature Methods}, + year = {2020}, + volume = {17}, + pages = {261--272}, + adsurl = {https://rdcu.be/b08Wh}, + doi = {https://doi.org/10.1038/s41592-019-0686-2}, +} + +@article{sklearn1, + author = {Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V. and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P. and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.}, + year = {2011}, + journal = {Journal of Machine Learning Research}, + pages = {2825--2830}, + title = {Scikit-learn: Machine Learning in {P}ython}, + volume = {12}, +} + +@inproceedings{sklearn2, + author = {Buitinck, Lars and Louppe, Gilles and Blondel, Mathieu and Pedregosa, Fabian and Mueller, Andreas and Grisel, Olivier and Niculae, Vlad and Prettenhofer, Peter and Gramfort, Alexandre and Grobler, Jaques and Layton, Robert and VanderPlas, Jake and Joly, Arnaud and Holt, Brian and Varoquaux, Gaël}, + booktitle = {ECML PKDD Workshop: Languages for Data Mining and Machine Learning}, + year = {2013}, + pages = {108--122}, + title = {{API} design for machine learning software: experiences from the scikit-learn project}, +} + + +@article{tabibian2019enhancinghumanlearningviaspacedrepetitionoptimization, + author = {Behzad Tabibian and Utkarsh Upadhyay and Abir De and + Ali Zarezade and Bernhard Sch{\"o}lkopf and Manuel + Gomez-Rodriguez}, + title = {Enhancing human learning via spaced repetition + optimization}, + journal = {Proceedings of the National Academy of Sciences}, + volume = 116, + number = 10, + pages = {3988-3993}, + year = 2019, + doi = {10.1073/pnas.1815156116}, + url = {http://dx.doi.org/10.1073/pnas.1815156116}, + DATE_ADDED = {Mon Aug 19 18:40:55 2024}, +} + diff --git a/papers/blaine_mooers/myst.yml b/papers/blaine_mooers/myst.yml new file mode 100644 index 0000000000..c09061faa3 --- /dev/null +++ b/papers/blaine_mooers/myst.yml @@ -0,0 +1,44 @@ +# See docs at: https://mystmd.org/guide/frontmatter +version: 1 +project: + id: scipy-2024-blaine_mooers + # id: 748163c7-a7d5-41f6-b9a0-337ab3b5f6d6 + title: Voice Computing with Python in Jupyter Notebooks + # description: + keywords: + - accessibility + - productivity + - human-computer interface + authors: + - name: Blaine H. M. Mooers + email: blaine-mooers@ouhsc.edu + orcid: 0000-0001-8181-8987 + affiliations: + - Department of Biochemistry and Physiology, College of Medicine, University of Oklahoma Health Sciences, Oklahoma City, OK 73104, USA + - Laboratory of Biomolecular Structure and Function, University of Oklahoma Health Sciences, Oklahoma City, OK 73104, USA + - Stephenson Cancer Center, University of Oklahoma Health Sciences, Oklahoma City, OK 73104, USA + corresponding: true + github: https://github.com/mooerslab/scipy_proceedings + # bibliography: [] + # title: + # options: + # favicon: favicon.ico + # logo: site_logo.png + error_rules: + - rule: doi-exists + severity: ignore + keys: + - Atr03 + - terradesert + - jupyter + - sklearn1 + - sklearn2 + # A banner will be generated for you on publication, this is a placeholder + banner: banner.png + subject: Research Article + open_access: true + license: CC-BY-4.0 + venue: Scipy 2024 + date: 2024-07-10 +site: + template: article-theme \ No newline at end of file