http://wikis.swarthmore.edu/ling073/api.php?action=feedcontributions&feedformat=atom&user=Ltarlin1LING073 - User contributions [en]2026-10-25T16:02:50ZUser contributionsMediaWiki 1.27.7http://wikis.swarthmore.edu/ling073/index.php?title=Chamorro/Disambiguation&diff=5481Chamorro/Disambiguation2017-05-14T00:52:55Z<p>Ltarlin1: </p>
<hr />
<div>== Code ==<br />
[https://github.swarthmore.edu/ltarlin1/ling073-cha Link to Github page]<br />
<br />
== Initial Evaluation of Ambiguity ==<br />
Initial ambiguity is 1.345 (2031 analyses of 1510 tokens).<br />
* Many of the ambiguous forms are pronouns. The way the transducer works at this moment, I gave every pronoun the ability to be analyzed in any person and number. I wasn't sure if this was the best way to go about it, but it does cause a lot of multiple analyses in this disambiguation phase. Also, this initial evaluation includes the two sentences (listed below) that I added to the corpus to test the disambiguator so that the size of the corpus would be constant before and after this step.<br />
<br />
== Example ==<br />
Words can sometimes be either nouns, verbs, or adjectives depending on the surrounding context. For example, the word 'dánkolo' takes a different grammatical role in the two following sentences:<br />
* Hu liʼeʼ i dánkolo (I saw the big one)<br />
* Hu liʼeʼ i dánkolo na taotao (I saw the big person)<br />
<br />
In the first sentence, the word serves as a noun because there is no other noun later in the sentence. However, in the second sentence, the noun 'taotao (person)' is present, making 'dánkolo' into an adjective. I believe that in any sentence of the form of the second sentence, the noun that the adjective modifies will be exactly two words away. Therefore, the constraint that I will use is that every time that a noun is two words after the adjective/noun ambiguous word, the transducer should select the adjective analysis of the word. Conversely, whenever this context does not appear, I will force the transducer to default to the noun reading.<br />
<br />
== Final Evaluation of Ambiguity ==<br />
Final ambiguity is 1.344 (2029 analyses of 1510 tokens).<br />
* This makes sense because the disambiguation rule I wrote focused specifically on a single construction that did not appear at all in my original corpus. Therefore, the only two sentences with ambiguities removed were the two that I added to test whether the rules were working.<br />
<br />
<br />
[[Category:Sp17 Disambiguation]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Chamorro/Disambiguation&diff=5445Chamorro/Disambiguation2017-05-12T05:18:49Z<p>Ltarlin1: /* Code */</p>
<hr />
<div>== Code ==<br />
[https://github.swarthmore.edu/ltarlin1/ling073-cha Link to Github page]<br />
<br />
== Initial Evaluation of Ambiguity ==<br />
Initial ambiguity is 1.345 (2031 analyses of 1510 tokens).<br />
* Many of the ambiguous forms are pronouns. The way the transducer works at this moment, I gave every pronoun the ability to be analyzed in any person and number. I wasn't sure if this was the best way to go about it, but it does cause a lot of multiple analyses in this disambiguation phase. Also, this initial evaluation includes the two sentences (listed below) that I added to the corpus to test the disambiguator so that the size of the corpus would be constant before and after this step.<br />
<br />
== Example ==<br />
Words can sometimes be either nouns, verbs, or adjectives depending on the surrounding context. For example, the word 'dánkolo' takes a different grammatical role in the two following sentences:<br />
* Hu liʼeʼ i dánkolo (I saw the big one)<br />
* Hu liʼeʼ i dánkolo na taotao (I saw the big person)<br />
<br />
In the first sentence, the word serves as a noun because there is no other noun later in the sentence. However, in the second sentence, the noun 'taotao (person)' is present, making 'dánkolo' into an adjective. I believe that in any sentence of the form of the second sentence, the noun that the adjective modifies will be exactly two words away. Therefore, the constraint that I will use is that every time that a noun is two words after the adjective/noun ambiguous word, the transducer should select the adjective analysis of the word.<br />
<br />
== Final Evaluation of Ambiguity ==<br />
Final ambiguity is 1.344 (2030 analyses of 1510 tokens).<br />
* This makes sense because the disambiguation rule I wrote focused specifically on a single construction that did not appear at all in my original corpus. The only reason that both new sentences were not analyzed correctly was that I could not figure out how to make it default to the noun unless the sentence fit the specified environment.<br />
<br />
<br />
[[Category:Sp17 Disambiguation]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Chamorro/Disambiguation&diff=5444Chamorro/Disambiguation2017-05-12T05:18:36Z<p>Ltarlin1: /* Code */</p>
<hr />
<div>== Code ==<br />
[https://github.swarthmore.edu/ltarlin1/ling073-cha Code]<br />
<br />
== Initial Evaluation of Ambiguity ==<br />
Initial ambiguity is 1.345 (2031 analyses of 1510 tokens).<br />
* Many of the ambiguous forms are pronouns. The way the transducer works at this moment, I gave every pronoun the ability to be analyzed in any person and number. I wasn't sure if this was the best way to go about it, but it does cause a lot of multiple analyses in this disambiguation phase. Also, this initial evaluation includes the two sentences (listed below) that I added to the corpus to test the disambiguator so that the size of the corpus would be constant before and after this step.<br />
<br />
== Example ==<br />
Words can sometimes be either nouns, verbs, or adjectives depending on the surrounding context. For example, the word 'dánkolo' takes a different grammatical role in the two following sentences:<br />
* Hu liʼeʼ i dánkolo (I saw the big one)<br />
* Hu liʼeʼ i dánkolo na taotao (I saw the big person)<br />
<br />
In the first sentence, the word serves as a noun because there is no other noun later in the sentence. However, in the second sentence, the noun 'taotao (person)' is present, making 'dánkolo' into an adjective. I believe that in any sentence of the form of the second sentence, the noun that the adjective modifies will be exactly two words away. Therefore, the constraint that I will use is that every time that a noun is two words after the adjective/noun ambiguous word, the transducer should select the adjective analysis of the word.<br />
<br />
== Final Evaluation of Ambiguity ==<br />
Final ambiguity is 1.344 (2030 analyses of 1510 tokens).<br />
* This makes sense because the disambiguation rule I wrote focused specifically on a single construction that did not appear at all in my original corpus. The only reason that both new sentences were not analyzed correctly was that I could not figure out how to make it default to the noun unless the sentence fit the specified environment.<br />
<br />
<br />
[[Category:Sp17 Disambiguation]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Chamorro/Disambiguation&diff=5443Chamorro/Disambiguation2017-05-12T05:17:26Z<p>Ltarlin1: </p>
<hr />
<div>== Code ==<br />
<br />
== Initial Evaluation of Ambiguity ==<br />
Initial ambiguity is 1.345 (2031 analyses of 1510 tokens).<br />
* Many of the ambiguous forms are pronouns. The way the transducer works at this moment, I gave every pronoun the ability to be analyzed in any person and number. I wasn't sure if this was the best way to go about it, but it does cause a lot of multiple analyses in this disambiguation phase. Also, this initial evaluation includes the two sentences (listed below) that I added to the corpus to test the disambiguator so that the size of the corpus would be constant before and after this step.<br />
<br />
== Example ==<br />
Words can sometimes be either nouns, verbs, or adjectives depending on the surrounding context. For example, the word 'dánkolo' takes a different grammatical role in the two following sentences:<br />
* Hu liʼeʼ i dánkolo (I saw the big one)<br />
* Hu liʼeʼ i dánkolo na taotao (I saw the big person)<br />
<br />
In the first sentence, the word serves as a noun because there is no other noun later in the sentence. However, in the second sentence, the noun 'taotao (person)' is present, making 'dánkolo' into an adjective. I believe that in any sentence of the form of the second sentence, the noun that the adjective modifies will be exactly two words away. Therefore, the constraint that I will use is that every time that a noun is two words after the adjective/noun ambiguous word, the transducer should select the adjective analysis of the word.<br />
<br />
== Final Evaluation of Ambiguity ==<br />
Final ambiguity is 1.344 (2030 analyses of 1510 tokens).<br />
* This makes sense because the disambiguation rule I wrote focused specifically on a single construction that did not appear at all in my original corpus. The only reason that both new sentences were not analyzed correctly was that I could not figure out how to make it default to the noun unless the sentence fit the specified environment.<br />
<br />
<br />
[[Category:Sp17 Disambiguation]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Chamorro/Disambiguation&diff=5442Chamorro/Disambiguation2017-05-12T02:56:57Z<p>Ltarlin1: </p>
<hr />
<div>== Initial Evaluation of Ambiguity ==<br />
Initial ambiguity is 1.338 (2005 analyses of 1498 tokens).<br />
* Many of the ambiguous forms are pronouns. The way the transducer works at this moment, I gave every pronoun the ability to be analyzed in any person and number. I wasn't sure if this was the best way to go about it, but it does cause a lot of multiple analyses in this disambiguation phase.<br />
<br />
== Example ==<br />
Words can sometimes be either nouns, verbs, or adjectives depending on the surrounding context. For example, the word 'dánkolo' takes a different grammatical role in the two following sentences:<br />
* Hu liʼeʼ i dánkolo (I saw the big one)<br />
* Hu liʼeʼ i dánkolo na taotao (I saw the big person)<br />
<br />
In the first sentence, the word serves as a noun because there is no other noun later in the sentence. However, in the second sentence, the noun 'taotao (person)' is present, making 'dánkolo' into an adjective. I believe that in any sentence of the form of the second sentence, the noun that the adjective modifies will be exactly two words away. Therefore, the constraint that I will use is that every time that a noun is two words after the adjective/noun ambiguous word, the transducer should select the adjective analysis of the word.<br />
<br />
[[Category:Sp17 Disambiguation]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Chamorro/Disambiguation&diff=5441Chamorro/Disambiguation2017-05-12T02:44:21Z<p>Ltarlin1: </p>
<hr />
<div>== Initial Evaluation of Ambiguity ==<br />
Initial ambiguity is 1.338 (2005 analyses of 1498 tokens).<br />
* Many of the ambiguous forms are pronouns. The way the transducer works at this moment, I gave every pronoun the ability to be analyzed in any person and number. I wasn't sure if this was the best way to go about it, but it does cause a lot of multiple analyses in this disambiguation phase.<br />
<br />
[[Category:Sp17 Disambiguation]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Chamorro&diff=5434Chamorro2017-05-12T00:18:42Z<p>Ltarlin1: </p>
<hr />
<div>== Developed Resources ==<br />
* https://wikis.swarthmore.edu/ling073/Chamorro/Keyboard<br />
* https://github.swarthmore.edu/ltarlin1/-ling073-cha-keyboard<br />
* https://github.swarthmore.edu/ltarlin1/ling073-cha-corpus<br />
* https://wikis.swarthmore.edu/ling073/Chamorro/Grammar<br />
* https://github.swarthmore.edu/ltarlin1/ling073-cha<br />
* https://wikis.swarthmore.edu/ling073/Chamorro/Transducer<br />
* https://wikis.swarthmore.edu/ling073/Chamorro/Disambiguation<br />
Resources for machine translation between Bikol and Chamorro <br />
* https://wikis.swarthmore.edu/ling073/Bikol_and_Chamorro<br />
<br />
== External Resources ==<br />
=== Computational Resources ===<br />
I could not find any computational resources for Chamorro.<br />
<br />
=== Dictionaries ===<br />
* Learn Chamorro app, available on iOS and Android <ref>http://www.chamoru.info/learn-chamorro-app/</ref> [Copyright 2017, all rights reserved]<br />
* Online dictionary, appears to have a variety of words and phrases <ref>http://www.chamoru.info/dictionary/</ref> [Copyright 2015 by Chamoru.Info, all rights reserved]<br />
* List of words, with a few unhelpful annotations <ref>http://language.psy.auckland.ac.nz/austronesian/language.php?id=18</ref> [Creative commons attribution license]<br />
* Chamorro cultural glossary, not too many words but maybe still helpful <ref>http://www.guampedia.com/haleta-chamorro-cultural-glossary/</ref> [Copyrighted in 2014 by Guampedia]<br />
* Chamorro-English dictionary available at McCabe (Topping, Donald M. Chamorro-English dictionary. Honolulu: University Press of Hawaii, 1975. Print.) [All rights reserved]<br />
<br />
=== Grammars ===<br />
* Reference grammar available at McCabe, should be useful for linguistic resources (Topping, Donald M, and Bernadita Camacho-Dungca. Chamorro Reference Grammar. Honolulu: University Press of Hawaii, 1973. Print.) [All rights reserved]<br />
* Guampedia has lots of materials, including a description of orthography rules <ref>http://www.guampedia.com/chamorro-orthography-rules/</ref> [Copyrighted in 2014 by Guampedia]<br />
* Dictionary and grammar of the Chamorro language from 1918 <ref>https://archive.org/details/dictionarygramma00preirich</ref> [Public domain]<br />
<br />
=== Scientific works ===<br />
* Glottolog lists many resources, but I don't know how available these are <ref>http://glottolog.org/resource/languoid/id/cham1312</ref> [Creative commons attribution license]<br />
* Guampedia also has an article about the history of Chamorro orthography <ref>http://www.guampedia.com/chamorro-orthography/</ref> [Copyrighted in 2014 by Guampedia]<br />
* The Chamorro Language of Guam, published in 1903, free for download <ref>https://www.jstor.org/stable/659055?seq=1#page_scan_tab_contents</ref> [Request permissions for copyright]<br />
* Alternative Analyses of Chamorro Vowels, from 1973, free for download <ref>http://www.jstor.org/stable/30029125?seq=1#page_scan_tab_contents</ref> [Request permissions for copyright]<br />
<br />
=== Corpora ===<br />
* Found online Bible translated in 1908, seems very complete <ref>https://www.stepbible.org/version.jsp?version=Chamorro</ref> [Copyrights listed on page]<br />
* Other online bible, used for translation part of semester <ref>http://paralleltext.info/data/cha-x-bible-2010/41/001/</ref><br />
* Universal declaration of human rights <ref>http://www.ohchr.org/EN/UDHR/Pages/Language.aspx?LangID=cjd</ref><br />
* Translation of 1671 speech by Chief Hurao of Guam <ref>http://ns.gov.gu/hurao.html</ref> [Unsure about copyright]<br />
* 418 content pages on Wikipedia, but most have very little text <ref>https://ch.wikipedia.org/w/index.php?title=Espesiat:AllPages&hideredirects=1</ref> [Creative Commons license]<br />
** the page for Indonesia has a couple sentences, which may be helpful<br />
<br />
=== References ===<br />
<references /><br />
<br />
[[Category:sp17_ResourceDocumentation]]<br />
[[Category:Chamorro]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Chamorro/Disambiguation&diff=5433Chamorro/Disambiguation2017-05-12T00:17:57Z<p>Ltarlin1: Created page with "boop Category:Sp17 Disambiguation"</p>
<hr />
<div>boop<br />
<br />
[[Category:Sp17 Disambiguation]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Ltarlin1/Final_Project&diff=5398Ltarlin1/Final Project2017-05-11T03:14:14Z<p>Ltarlin1: </p>
<hr />
<div>== Code ==<br />
[https://github.swarthmore.edu/ltarlin1/ling073-ltarlin1-autoglosser Private link]<br />
[https://github.com/mercurio83/ling073-ltarlin1-autoglosser Public link]<br />
<br />
== The Problem ==<br />
For my final project, I decided to create an autoglosser that would automatically convert the universal dependency files we worked with in class into visual form in Latex. There is a Latex package called [http://mirror.unl.edu/ctan/graphics/pgf/contrib/tikz-dependency/tikz-dependency-doc.pdf tikz-dependency] that allows for quick input of sentences and its corresponding dependencies, but it still requires the user to manually select each dependency. Therefore, my code automatically generates Latex code that fits the expected format for the tikz-dependency package and therefore can easily be displayed in a graph, as in the following example image:<br />
<br />
[[File:Lee-tikz-dependency.png|800px|Dependency tree of "An example output of the tikz-dependency latex package.]]<br />
<br />
Although this graph is fancy and colorful, the output of my code is a simplified version that includes all of the most relevant information and has some customizable features. A description of the code, the output, and how to run the program follows.<br />
<br />
== Previous Work ==<br />
As discussed in the above section, the tikz-dependency package uses the tikz interface to facilitate the graph-making process. The syntax of a dependency in this format is strikingly similar to that which we saw in class (i.e. #4->6) because both refer to the "from word" and the "to word" using offset from the beginning of the sentence, so it was relatively simple to translate from one form to another.<br />
<br />
== Who Will Benefit ==<br />
This tool would be useful for linguists who want to speed up the visual-making process when working with universal dependencies. It does not have much of an application outside the technical linguistics domain because generating the input files to my program requires prior knowledge of universal dependencies.<br />
<br />
== Basic Solution ==<br />
My autoglosser parses each line of the CG file and separates it into the relevant portions--the words that make up the sentence, each corresponding part of speech, the other side of the dependency, and the type of dependence relationship. The more specific part-of-speech information present in the CG file is ignored because it would clutter the sentence diagram if it were included.<br />
<br />
Therefore, a CG file like the one we looked at in class<br />
<pre><br />
"<The>"<br />
"The" det def sp @det #1->4<br />
"<quick>"<br />
"quick" adj sint @amod #2->4<br />
"<brown>"<br />
"brown" adj @amod #3->4<br />
"<fox>"<br />
"fox" n sg @nsubj #4->5<br />
"<jumps>"<br />
"jump" vblex pres p3 sg @root #5->0<br />
"<over>"<br />
"over" pr @case #6->9<br />
"<the>"<br />
"the" det def sp @det #7->9<br />
"<lazy>"<br />
"lazy" adj sint @amod #8->9<br />
"<dog>"<br />
"dog" n sg @obl #9->5<br />
"<in>"<br />
"in" pr @case #10->13<br />
"<the>"<br />
"the" det def sp @det #11->13<br />
"<green>"<br />
"green" adj sint @amod #12->13<br />
"<fields>"<br />
"field" n pl @obl #13->5<br />
"<.>"<br />
"." sent<br />
</pre><br />
<br />
is turned into something like this:<br />
<pre><br />
words = ['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog', 'in', 'the', 'green', 'fields', '.']<br />
<br />
info = [<br />
['"The"', 'det', 'def', 'sp', '@det', '#1->4'], <br />
['"quick"', 'adj', 'sint', '@amod', '#2->4'], <br />
['"brown"', 'adj', '@amod', '#3->4'], <br />
['"fox"', 'n', 'sg', '@nsubj', '#4->5'], <br />
['"jump"', 'vblex', 'pres', 'p3', 'sg', '@root', '#5->0'], <br />
['"over"', 'pr', '@case', '#6->9'], <br />
['"the"', 'det', 'def', 'sp', '@det', '#7->9'], <br />
['"lazy"', 'adj', 'sint', '@amod', '#8->9'], <br />
['"dog"', 'n', 'sg', '@obl', '#9->5'], <br />
['"in"', 'pr', '@case', '#10->13'], <br />
['"the"', 'det', 'def', 'sp', '@det', '#11->13'], <br />
['"green"', 'adj', 'sint', '@amod', '#12->13'], <br />
['"field"', 'n', 'pl', '@obl', '#13->5'], <br />
['"."', 'sent']]<br />
</pre><br />
<br />
The next step that my program takes is using string formatting to extract the relevant aspects of this "info"--namely the "from word", the "to word", and the type of dependency (indicated by the '@' symbol). Once I have all of this information, I can simply plug it into the corresponding locations in the desired format. Therefore, the final Latex code outputted by the simplest version of my program is<br />
<br />
<pre><br />
\begin{dependency}<br />
\begin{deptext}[column sep=0.2cm]<br />
The \& quick \& brown \& fox \& jumps \& over \& the \& lazy \& dog \& in \& the \& green \& fields \& ROOT \\ <br />
\end{deptext}<br />
\depedge{4}{1}{det}<br />
\depedge{4}{2}{amod}<br />
\depedge{4}{3}{amod}<br />
\depedge{5}{4}{nsubj}<br />
\depedge{14}{5}{root}<br />
\depedge{9}{6}{case}<br />
\depedge{9}{7}{det}<br />
\depedge{9}{8}{amod}<br />
\depedge{5}{9}{obl}<br />
\depedge{13}{10}{case}<br />
\depedge{13}{11}{det}<br />
\depedge{13}{12}{amod}<br />
\depedge{5}{13}{obl}<br />
\end{dependency}<br />
</pre><br />
<br />
Once you add the line <code>\usepackage{tikz-dependency}</code> to a blank Latex file, you can add this code and get the resulting image:<br />
<br />
[[File:example graph basic.png|800px|Dependency tree of "The resulting graph after running the original CG dependency file through my program.]]<br />
<br />
== More Complicated Solution ==<br />
I also added several customizable features to the program. I will briefly explain how each works here.<br />
<br />
=== Visible POS Tags ===<br />
I added the capability to display the part of speech tags below the text of the sentence. However, since this option may not always be desired, one of the command line arguments for the program toggles it on or off. This is the same graph as above, except with the POS tags visible:<br />
<br />
[[File:example graph with pos.png|800px|Dependency tree of "The resulting graph after setting the POS tags as visible.]]<br />
<br />
=== Dependency Filter ===<br />
In some situations, it may be useful to only view dependencies of a certain type. My tool allows you to optionally specify specific tag names that you want to appear in the graph. If no individual dependency types are listed, it will default to showing all of them. This is the same sentence as the previous examples, but this time with only the 'amod' dependencies displayed:<br />
<br />
[[File:example graph with pos and filter.png|800px|Dependency tree of "The resulting graph after only displaying dependencies of type 'amod'.]]<br />
<br />
=== Batch Diagramming ===<br />
If this dependency visualization is done on a large scale, it would be tedious to run the program separately for each individual sentence in the corpus. To speed things up, I implemented an option to input a .txt file with a list of filenames. The autoglosser will take that list and generate a separate output file (containing Latex code) for each filename in the list. This makes large scale diagramming more efficient and only requires the user to construct one large file.<br />
<br />
== Hard-coded Parameters ==<br />
There were several design choices that I made because I thought they looked the best, but these can be changed with simple edits to the autoglosser.py file.<br />
<br />
=== Column/Row Spacing ===<br />
I added a default 0.2cm gap between columns (words) and a default 0.2ex gap between rows (only relevant when POS tags are visible).<br />
<br />
=== Word Spacing ===<br />
When there was a dependency between two consecutive words, the label was sometimes wider than the connecting arrow. To clean up the visual, I added an extra 0.5cm between columns whenever this occurred.<br />
<br />
=== Filename Format ===<br />
In my code, I hard-coded the program to take input files in the form "<label>_input.txt" and to create output files in the form "<label>_output.txt".<br />
<br />
== Usage ==<br />
Clone the github repository found [https://github.swarthmore.edu/ltarlin1/ling073-ltarlin1-autoglosser here]. The <code>autoglosser.py</code> file can be run with the following format: <code>python autoglosser.py [input file] [type] [POS tags] <dependencies to include - OPTIONAL></code>. Each of these arguments is explained in more detail below:<br />
* '''input file''': This argument specifies the CG file to be diagrammed. The code expects the name of the file to follow the form "<label>_input.txt", but this parameter only requires the label. For example, if the desired input file were "fox_input.txt", this argument would simply be "fox". The exception to this rule is if the user wants to do batch processing, in which case this argument is simply the name of the file containing the other filenames.<br />
* '''type''': This argument specifies whether the input file is a single sentence or a list of filenames. The options are m (for multiple, or batch processing) or s (for a single sentence).<br />
* '''POS tags''': This argument specifies whether the part-of-speech tags should be displayed below the text of the sentence. The options are 1 (for yes) or 0 (for no).<br />
* '''[OPTIONAL] Dependencies''' : This optional argument (or arguments) are the specific dependency types that should be displayed in the graph. If more than one is desired, simply list them here separated by spaces. For example, if you wanted to only see dependencies of type "det" and "amod", you would add "det amod" after the POS tag argument.<br />
<br />
== Evaluation ==<br />
I evaluated the quality of the autoglosser by the extent to which it accomplished the things I set out to accomplish. On a most basic level, the project goal was to provide an automatic way to visualize the syntactic dependencies of a sentence in Latex. Not only did my code do this, it provided additional customization to selectively view certain portions of the diagram. It also allowed for automatic batch processing to expedite the visualization process for a large corpus. Although there are still ways that the functionality of the autoglosser could be expanded and the aesthetics improved, the results that I got are what I hoped to produce for this final project.<br />
<br />
[[Category:sp17_FinalProjects]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Ltarlin1/Final_Project&diff=5311Ltarlin1/Final Project2017-05-10T06:47:02Z<p>Ltarlin1: /* Usage */</p>
<hr />
<div>== Code ==<br />
[https://github.swarthmore.edu/ltarlin1/ling073-ltarlin1-autoglosser Github link]<br />
<br />
== The Problem ==<br />
For my final project, I decided to create an autoglosser that would automatically convert the universal dependency files we worked with in class into visual form in Latex. There is a Latex package called [http://mirror.unl.edu/ctan/graphics/pgf/contrib/tikz-dependency/tikz-dependency-doc.pdf tikz-dependency] that allows for quick input of sentences and its corresponding dependencies, but it still requires the user to manually select each dependency. Therefore, my code automatically generates Latex code that fits the expected format for the tikz-dependency package and therefore can easily be displayed in a graph, as in the following example image:<br />
<br />
[[File:Lee-tikz-dependency.png|800px|Dependency tree of "An example output of the tikz-dependency latex package.]]<br />
<br />
Although this graph is fancy and colorful, the output of my code is a simplified version that includes all of the most relevant information and has some customizable features. A description of the code, the output, and how to run the program follows.<br />
<br />
== Previous Work ==<br />
As discussed in the above section, the tikz-dependency package uses the tikz interface to facilitate the graph-making process. The syntax of a dependency in this format is strikingly similar to that which we saw in class (i.e. #4->6) because both refer to the "from word" and the "to word" using offset from the beginning of the sentence, so it was relatively simple to translate from one form to another.<br />
<br />
== Who Will Benefit ==<br />
This tool would be useful for linguists who want to speed up the visual-making process when working with universal dependencies. It does not have much of an application outside the technical linguistics domain because generating the input files to my program requires prior knowledge of universal dependencies.<br />
<br />
== Basic Solution ==<br />
My autoglosser parses each line of the CG file and separates it into the relevant portions--the words that make up the sentence, each corresponding part of speech, the other side of the dependency, and the type of dependence relationship. The more specific part-of-speech information present in the CG file is ignored because it would clutter the sentence diagram if it were included.<br />
<br />
Therefore, a CG file like the one we looked at in class<br />
<pre><br />
"<The>"<br />
"The" det def sp @det #1->4<br />
"<quick>"<br />
"quick" adj sint @amod #2->4<br />
"<brown>"<br />
"brown" adj @amod #3->4<br />
"<fox>"<br />
"fox" n sg @nsubj #4->5<br />
"<jumps>"<br />
"jump" vblex pres p3 sg @root #5->0<br />
"<over>"<br />
"over" pr @case #6->9<br />
"<the>"<br />
"the" det def sp @det #7->9<br />
"<lazy>"<br />
"lazy" adj sint @amod #8->9<br />
"<dog>"<br />
"dog" n sg @obl #9->5<br />
"<in>"<br />
"in" pr @case #10->13<br />
"<the>"<br />
"the" det def sp @det #11->13<br />
"<green>"<br />
"green" adj sint @amod #12->13<br />
"<fields>"<br />
"field" n pl @obl #13->5<br />
"<.>"<br />
"." sent<br />
</pre><br />
<br />
is turned into something like this:<br />
<pre><br />
words = ['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog', 'in', 'the', 'green', 'fields', '.']<br />
<br />
info = [<br />
['"The"', 'det', 'def', 'sp', '@det', '#1->4'], <br />
['"quick"', 'adj', 'sint', '@amod', '#2->4'], <br />
['"brown"', 'adj', '@amod', '#3->4'], <br />
['"fox"', 'n', 'sg', '@nsubj', '#4->5'], <br />
['"jump"', 'vblex', 'pres', 'p3', 'sg', '@root', '#5->0'], <br />
['"over"', 'pr', '@case', '#6->9'], <br />
['"the"', 'det', 'def', 'sp', '@det', '#7->9'], <br />
['"lazy"', 'adj', 'sint', '@amod', '#8->9'], <br />
['"dog"', 'n', 'sg', '@obl', '#9->5'], <br />
['"in"', 'pr', '@case', '#10->13'], <br />
['"the"', 'det', 'def', 'sp', '@det', '#11->13'], <br />
['"green"', 'adj', 'sint', '@amod', '#12->13'], <br />
['"field"', 'n', 'pl', '@obl', '#13->5'], <br />
['"."', 'sent']]<br />
</pre><br />
<br />
The next step that my program takes is using string formatting to extract the relevant aspects of this "info"--namely the "from word", the "to word", and the type of dependency (indicated by the '@' symbol). Once I have all of this information, I can simply plug it into the corresponding locations in the desired format. Therefore, the final Latex code outputted by the simplest version of my program is<br />
<br />
<pre><br />
\begin{dependency}<br />
\begin{deptext}[column sep=0.2cm]<br />
The \& quick \& brown \& fox \& jumps \& over \& the \& lazy \& dog \& in \& the \& green \& fields \& ROOT \\ <br />
\end{deptext}<br />
\depedge{4}{1}{det}<br />
\depedge{4}{2}{amod}<br />
\depedge{4}{3}{amod}<br />
\depedge{5}{4}{nsubj}<br />
\depedge{14}{5}{root}<br />
\depedge{9}{6}{case}<br />
\depedge{9}{7}{det}<br />
\depedge{9}{8}{amod}<br />
\depedge{5}{9}{obl}<br />
\depedge{13}{10}{case}<br />
\depedge{13}{11}{det}<br />
\depedge{13}{12}{amod}<br />
\depedge{5}{13}{obl}<br />
\end{dependency}<br />
</pre><br />
<br />
Once you add the line <code>\usepackage{tikz-dependency}</code> to a blank Latex file, you can add this code and get the resulting image:<br />
<br />
[[File:example graph basic.png|800px|Dependency tree of "The resulting graph after running the original CG dependency file through my program.]]<br />
<br />
== More Complicated Solution ==<br />
I also added several customizable features to the program. I will briefly explain how each works here.<br />
<br />
=== Visible POS Tags ===<br />
I added the capability to display the part of speech tags below the text of the sentence. However, since this option may not always be desired, one of the command line arguments for the program toggles it on or off. This is the same graph as above, except with the POS tags visible:<br />
<br />
[[File:example graph with pos.png|800px|Dependency tree of "The resulting graph after setting the POS tags as visible.]]<br />
<br />
=== Dependency Filter ===<br />
In some situations, it may be useful to only view dependencies of a certain type. My tool allows you to optionally specify specific tag names that you want to appear in the graph. If no individual dependency types are listed, it will default to showing all of them. This is the same sentence as the previous examples, but this time with only the 'amod' dependencies displayed:<br />
<br />
[[File:example graph with pos and filter.png|800px|Dependency tree of "The resulting graph after only displaying dependencies of type 'amod'.]]<br />
<br />
=== Batch Diagramming ===<br />
If this dependency visualization is done on a large scale, it would be tedious to run the program separately for each individual sentence in the corpus. To speed things up, I implemented an option to input a .txt file with a list of filenames. The autoglosser will take that list and generate a separate output file (containing Latex code) for each filename in the list. This makes large scale diagramming more efficient and only requires the user to construct one large file.<br />
<br />
== Hard-coded Parameters ==<br />
There were several design choices that I made because I thought they looked the best, but these can be changed with simple edits to the autoglosser.py file.<br />
<br />
=== Column/Row Spacing ===<br />
I added a default 0.2cm gap between columns (words) and a default 0.2ex gap between rows (only relevant when POS tags are visible).<br />
<br />
=== Word Spacing ===<br />
When there was a dependency between two consecutive words, the label was sometimes wider than the connecting arrow. To clean up the visual, I added an extra 0.5cm between columns whenever this occurred.<br />
<br />
=== Filename Format ===<br />
In my code, I hard-coded the program to take input files in the form "<label>_input.txt" and to create output files in the form "<label>_output.txt".<br />
<br />
== Usage ==<br />
Clone the github repository found [https://github.swarthmore.edu/ltarlin1/ling073-ltarlin1-autoglosser here]. The <code>autoglosser.py</code> file can be run with the following format: <code>python autoglosser.py [input file] [type] [POS tags] <dependencies to include - OPTIONAL></code>. Each of these arguments is explained in more detail below:<br />
* '''input file''': This argument specifies the CG file to be diagrammed. The code expects the name of the file to follow the form "<label>_input.txt", but this parameter only requires the label. For example, if the desired input file were "fox_input.txt", this argument would simply be "fox". The exception to this rule is if the user wants to do batch processing, in which case this argument is simply the name of the file containing the other filenames.<br />
* '''type''': This argument specifies whether the input file is a single sentence or a list of filenames. The options are m (for multiple, or batch processing) or s (for a single sentence).<br />
* '''POS tags''': This argument specifies whether the part-of-speech tags should be displayed below the text of the sentence. The options are 1 (for yes) or 0 (for no).<br />
* '''[OPTIONAL] Dependencies''' : This optional argument (or arguments) are the specific dependency types that should be displayed in the graph. If more than one is desired, simply list them here separated by spaces. For example, if you wanted to only see dependencies of type "det" and "amod", you would add "det amod" after the POS tag argument.<br />
<br />
== Evaluation ==<br />
I evaluated the quality of the autoglosser by the extent to which it accomplished the things I set out to accomplish. On a most basic level, the project goal was to provide an automatic way to visualize the syntactic dependencies of a sentence in Latex. Not only did my code do this, it provided additional customization to selectively view certain portions of the diagram. It also allowed for automatic batch processing to expedite the visualization process for a large corpus. Although there are still ways that the functionality of the autoglosser could be expanded and the aesthetics improved, the results that I got are what I hoped to produce for this final project.<br />
<br />
[[Category:sp17_FinalProjects]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Ltarlin1/Final_Project&diff=5310Ltarlin1/Final Project2017-05-10T06:46:50Z<p>Ltarlin1: /* Usage */</p>
<hr />
<div>== Code ==<br />
[https://github.swarthmore.edu/ltarlin1/ling073-ltarlin1-autoglosser Github link]<br />
<br />
== The Problem ==<br />
For my final project, I decided to create an autoglosser that would automatically convert the universal dependency files we worked with in class into visual form in Latex. There is a Latex package called [http://mirror.unl.edu/ctan/graphics/pgf/contrib/tikz-dependency/tikz-dependency-doc.pdf tikz-dependency] that allows for quick input of sentences and its corresponding dependencies, but it still requires the user to manually select each dependency. Therefore, my code automatically generates Latex code that fits the expected format for the tikz-dependency package and therefore can easily be displayed in a graph, as in the following example image:<br />
<br />
[[File:Lee-tikz-dependency.png|800px|Dependency tree of "An example output of the tikz-dependency latex package.]]<br />
<br />
Although this graph is fancy and colorful, the output of my code is a simplified version that includes all of the most relevant information and has some customizable features. A description of the code, the output, and how to run the program follows.<br />
<br />
== Previous Work ==<br />
As discussed in the above section, the tikz-dependency package uses the tikz interface to facilitate the graph-making process. The syntax of a dependency in this format is strikingly similar to that which we saw in class (i.e. #4->6) because both refer to the "from word" and the "to word" using offset from the beginning of the sentence, so it was relatively simple to translate from one form to another.<br />
<br />
== Who Will Benefit ==<br />
This tool would be useful for linguists who want to speed up the visual-making process when working with universal dependencies. It does not have much of an application outside the technical linguistics domain because generating the input files to my program requires prior knowledge of universal dependencies.<br />
<br />
== Basic Solution ==<br />
My autoglosser parses each line of the CG file and separates it into the relevant portions--the words that make up the sentence, each corresponding part of speech, the other side of the dependency, and the type of dependence relationship. The more specific part-of-speech information present in the CG file is ignored because it would clutter the sentence diagram if it were included.<br />
<br />
Therefore, a CG file like the one we looked at in class<br />
<pre><br />
"<The>"<br />
"The" det def sp @det #1->4<br />
"<quick>"<br />
"quick" adj sint @amod #2->4<br />
"<brown>"<br />
"brown" adj @amod #3->4<br />
"<fox>"<br />
"fox" n sg @nsubj #4->5<br />
"<jumps>"<br />
"jump" vblex pres p3 sg @root #5->0<br />
"<over>"<br />
"over" pr @case #6->9<br />
"<the>"<br />
"the" det def sp @det #7->9<br />
"<lazy>"<br />
"lazy" adj sint @amod #8->9<br />
"<dog>"<br />
"dog" n sg @obl #9->5<br />
"<in>"<br />
"in" pr @case #10->13<br />
"<the>"<br />
"the" det def sp @det #11->13<br />
"<green>"<br />
"green" adj sint @amod #12->13<br />
"<fields>"<br />
"field" n pl @obl #13->5<br />
"<.>"<br />
"." sent<br />
</pre><br />
<br />
is turned into something like this:<br />
<pre><br />
words = ['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog', 'in', 'the', 'green', 'fields', '.']<br />
<br />
info = [<br />
['"The"', 'det', 'def', 'sp', '@det', '#1->4'], <br />
['"quick"', 'adj', 'sint', '@amod', '#2->4'], <br />
['"brown"', 'adj', '@amod', '#3->4'], <br />
['"fox"', 'n', 'sg', '@nsubj', '#4->5'], <br />
['"jump"', 'vblex', 'pres', 'p3', 'sg', '@root', '#5->0'], <br />
['"over"', 'pr', '@case', '#6->9'], <br />
['"the"', 'det', 'def', 'sp', '@det', '#7->9'], <br />
['"lazy"', 'adj', 'sint', '@amod', '#8->9'], <br />
['"dog"', 'n', 'sg', '@obl', '#9->5'], <br />
['"in"', 'pr', '@case', '#10->13'], <br />
['"the"', 'det', 'def', 'sp', '@det', '#11->13'], <br />
['"green"', 'adj', 'sint', '@amod', '#12->13'], <br />
['"field"', 'n', 'pl', '@obl', '#13->5'], <br />
['"."', 'sent']]<br />
</pre><br />
<br />
The next step that my program takes is using string formatting to extract the relevant aspects of this "info"--namely the "from word", the "to word", and the type of dependency (indicated by the '@' symbol). Once I have all of this information, I can simply plug it into the corresponding locations in the desired format. Therefore, the final Latex code outputted by the simplest version of my program is<br />
<br />
<pre><br />
\begin{dependency}<br />
\begin{deptext}[column sep=0.2cm]<br />
The \& quick \& brown \& fox \& jumps \& over \& the \& lazy \& dog \& in \& the \& green \& fields \& ROOT \\ <br />
\end{deptext}<br />
\depedge{4}{1}{det}<br />
\depedge{4}{2}{amod}<br />
\depedge{4}{3}{amod}<br />
\depedge{5}{4}{nsubj}<br />
\depedge{14}{5}{root}<br />
\depedge{9}{6}{case}<br />
\depedge{9}{7}{det}<br />
\depedge{9}{8}{amod}<br />
\depedge{5}{9}{obl}<br />
\depedge{13}{10}{case}<br />
\depedge{13}{11}{det}<br />
\depedge{13}{12}{amod}<br />
\depedge{5}{13}{obl}<br />
\end{dependency}<br />
</pre><br />
<br />
Once you add the line <code>\usepackage{tikz-dependency}</code> to a blank Latex file, you can add this code and get the resulting image:<br />
<br />
[[File:example graph basic.png|800px|Dependency tree of "The resulting graph after running the original CG dependency file through my program.]]<br />
<br />
== More Complicated Solution ==<br />
I also added several customizable features to the program. I will briefly explain how each works here.<br />
<br />
=== Visible POS Tags ===<br />
I added the capability to display the part of speech tags below the text of the sentence. However, since this option may not always be desired, one of the command line arguments for the program toggles it on or off. This is the same graph as above, except with the POS tags visible:<br />
<br />
[[File:example graph with pos.png|800px|Dependency tree of "The resulting graph after setting the POS tags as visible.]]<br />
<br />
=== Dependency Filter ===<br />
In some situations, it may be useful to only view dependencies of a certain type. My tool allows you to optionally specify specific tag names that you want to appear in the graph. If no individual dependency types are listed, it will default to showing all of them. This is the same sentence as the previous examples, but this time with only the 'amod' dependencies displayed:<br />
<br />
[[File:example graph with pos and filter.png|800px|Dependency tree of "The resulting graph after only displaying dependencies of type 'amod'.]]<br />
<br />
=== Batch Diagramming ===<br />
If this dependency visualization is done on a large scale, it would be tedious to run the program separately for each individual sentence in the corpus. To speed things up, I implemented an option to input a .txt file with a list of filenames. The autoglosser will take that list and generate a separate output file (containing Latex code) for each filename in the list. This makes large scale diagramming more efficient and only requires the user to construct one large file.<br />
<br />
== Hard-coded Parameters ==<br />
There were several design choices that I made because I thought they looked the best, but these can be changed with simple edits to the autoglosser.py file.<br />
<br />
=== Column/Row Spacing ===<br />
I added a default 0.2cm gap between columns (words) and a default 0.2ex gap between rows (only relevant when POS tags are visible).<br />
<br />
=== Word Spacing ===<br />
When there was a dependency between two consecutive words, the label was sometimes wider than the connecting arrow. To clean up the visual, I added an extra 0.5cm between columns whenever this occurred.<br />
<br />
=== Filename Format ===<br />
In my code, I hard-coded the program to take input files in the form "<label>_input.txt" and to create output files in the form "<label>_output.txt".<br />
<br />
== Usage ==<br />
Clone the github repository found [https://github.swarthmore.edu/ltarlin1/ling073-ltarlin1-autoglosser here]. The <code>autoglosser.py</code> file can be run with the following format: <code>python autoglosser.py [input file] [type] [POS tags] <dependencies to include - OPTIONAL></code>. Each of these arguments is explained in more detail below:<br />
* '''input file''': This argument specifies the CG file to be diagrammed. The code expects the name of the file to follow the form "<label>_input.txt", but this parameter only requires the label. For example, if the desired input file were "fox_input.txt", this argument would simply be "fox". The exception to this rule is if the user wants to do batch processing, in which case this argument is simply the name of the file containing the other filenames.<br />
* '''type''': This argument specifies whether the input file is a single sentence or a list of filenames. The options are "m" (for multiple, or batch processing) or "s" (for a single sentence).<br />
* '''POS tags''': This argument specifies whether the part-of-speech tags should be displayed below the text of the sentence. The options are 1 (for yes) or 0 (for no).<br />
* '''[OPTIONAL] Dependencies''' : This optional argument (or arguments) are the specific dependency types that should be displayed in the graph. If more than one is desired, simply list them here separated by spaces. For example, if you wanted to only see dependencies of type "det" and "amod", you would add "det amod" after the POS tag argument.<br />
<br />
== Evaluation ==<br />
I evaluated the quality of the autoglosser by the extent to which it accomplished the things I set out to accomplish. On a most basic level, the project goal was to provide an automatic way to visualize the syntactic dependencies of a sentence in Latex. Not only did my code do this, it provided additional customization to selectively view certain portions of the diagram. It also allowed for automatic batch processing to expedite the visualization process for a large corpus. Although there are still ways that the functionality of the autoglosser could be expanded and the aesthetics improved, the results that I got are what I hoped to produce for this final project.<br />
<br />
[[Category:sp17_FinalProjects]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Ltarlin1/Final_Project&diff=5309Ltarlin1/Final Project2017-05-10T06:45:25Z<p>Ltarlin1: </p>
<hr />
<div>== Code ==<br />
[https://github.swarthmore.edu/ltarlin1/ling073-ltarlin1-autoglosser Github link]<br />
<br />
== The Problem ==<br />
For my final project, I decided to create an autoglosser that would automatically convert the universal dependency files we worked with in class into visual form in Latex. There is a Latex package called [http://mirror.unl.edu/ctan/graphics/pgf/contrib/tikz-dependency/tikz-dependency-doc.pdf tikz-dependency] that allows for quick input of sentences and its corresponding dependencies, but it still requires the user to manually select each dependency. Therefore, my code automatically generates Latex code that fits the expected format for the tikz-dependency package and therefore can easily be displayed in a graph, as in the following example image:<br />
<br />
[[File:Lee-tikz-dependency.png|800px|Dependency tree of "An example output of the tikz-dependency latex package.]]<br />
<br />
Although this graph is fancy and colorful, the output of my code is a simplified version that includes all of the most relevant information and has some customizable features. A description of the code, the output, and how to run the program follows.<br />
<br />
== Previous Work ==<br />
As discussed in the above section, the tikz-dependency package uses the tikz interface to facilitate the graph-making process. The syntax of a dependency in this format is strikingly similar to that which we saw in class (i.e. #4->6) because both refer to the "from word" and the "to word" using offset from the beginning of the sentence, so it was relatively simple to translate from one form to another.<br />
<br />
== Who Will Benefit ==<br />
This tool would be useful for linguists who want to speed up the visual-making process when working with universal dependencies. It does not have much of an application outside the technical linguistics domain because generating the input files to my program requires prior knowledge of universal dependencies.<br />
<br />
== Basic Solution ==<br />
My autoglosser parses each line of the CG file and separates it into the relevant portions--the words that make up the sentence, each corresponding part of speech, the other side of the dependency, and the type of dependence relationship. The more specific part-of-speech information present in the CG file is ignored because it would clutter the sentence diagram if it were included.<br />
<br />
Therefore, a CG file like the one we looked at in class<br />
<pre><br />
"<The>"<br />
"The" det def sp @det #1->4<br />
"<quick>"<br />
"quick" adj sint @amod #2->4<br />
"<brown>"<br />
"brown" adj @amod #3->4<br />
"<fox>"<br />
"fox" n sg @nsubj #4->5<br />
"<jumps>"<br />
"jump" vblex pres p3 sg @root #5->0<br />
"<over>"<br />
"over" pr @case #6->9<br />
"<the>"<br />
"the" det def sp @det #7->9<br />
"<lazy>"<br />
"lazy" adj sint @amod #8->9<br />
"<dog>"<br />
"dog" n sg @obl #9->5<br />
"<in>"<br />
"in" pr @case #10->13<br />
"<the>"<br />
"the" det def sp @det #11->13<br />
"<green>"<br />
"green" adj sint @amod #12->13<br />
"<fields>"<br />
"field" n pl @obl #13->5<br />
"<.>"<br />
"." sent<br />
</pre><br />
<br />
is turned into something like this:<br />
<pre><br />
words = ['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog', 'in', 'the', 'green', 'fields', '.']<br />
<br />
info = [<br />
['"The"', 'det', 'def', 'sp', '@det', '#1->4'], <br />
['"quick"', 'adj', 'sint', '@amod', '#2->4'], <br />
['"brown"', 'adj', '@amod', '#3->4'], <br />
['"fox"', 'n', 'sg', '@nsubj', '#4->5'], <br />
['"jump"', 'vblex', 'pres', 'p3', 'sg', '@root', '#5->0'], <br />
['"over"', 'pr', '@case', '#6->9'], <br />
['"the"', 'det', 'def', 'sp', '@det', '#7->9'], <br />
['"lazy"', 'adj', 'sint', '@amod', '#8->9'], <br />
['"dog"', 'n', 'sg', '@obl', '#9->5'], <br />
['"in"', 'pr', '@case', '#10->13'], <br />
['"the"', 'det', 'def', 'sp', '@det', '#11->13'], <br />
['"green"', 'adj', 'sint', '@amod', '#12->13'], <br />
['"field"', 'n', 'pl', '@obl', '#13->5'], <br />
['"."', 'sent']]<br />
</pre><br />
<br />
The next step that my program takes is using string formatting to extract the relevant aspects of this "info"--namely the "from word", the "to word", and the type of dependency (indicated by the '@' symbol). Once I have all of this information, I can simply plug it into the corresponding locations in the desired format. Therefore, the final Latex code outputted by the simplest version of my program is<br />
<br />
<pre><br />
\begin{dependency}<br />
\begin{deptext}[column sep=0.2cm]<br />
The \& quick \& brown \& fox \& jumps \& over \& the \& lazy \& dog \& in \& the \& green \& fields \& ROOT \\ <br />
\end{deptext}<br />
\depedge{4}{1}{det}<br />
\depedge{4}{2}{amod}<br />
\depedge{4}{3}{amod}<br />
\depedge{5}{4}{nsubj}<br />
\depedge{14}{5}{root}<br />
\depedge{9}{6}{case}<br />
\depedge{9}{7}{det}<br />
\depedge{9}{8}{amod}<br />
\depedge{5}{9}{obl}<br />
\depedge{13}{10}{case}<br />
\depedge{13}{11}{det}<br />
\depedge{13}{12}{amod}<br />
\depedge{5}{13}{obl}<br />
\end{dependency}<br />
</pre><br />
<br />
Once you add the line <code>\usepackage{tikz-dependency}</code> to a blank Latex file, you can add this code and get the resulting image:<br />
<br />
[[File:example graph basic.png|800px|Dependency tree of "The resulting graph after running the original CG dependency file through my program.]]<br />
<br />
== More Complicated Solution ==<br />
I also added several customizable features to the program. I will briefly explain how each works here.<br />
<br />
=== Visible POS Tags ===<br />
I added the capability to display the part of speech tags below the text of the sentence. However, since this option may not always be desired, one of the command line arguments for the program toggles it on or off. This is the same graph as above, except with the POS tags visible:<br />
<br />
[[File:example graph with pos.png|800px|Dependency tree of "The resulting graph after setting the POS tags as visible.]]<br />
<br />
=== Dependency Filter ===<br />
In some situations, it may be useful to only view dependencies of a certain type. My tool allows you to optionally specify specific tag names that you want to appear in the graph. If no individual dependency types are listed, it will default to showing all of them. This is the same sentence as the previous examples, but this time with only the 'amod' dependencies displayed:<br />
<br />
[[File:example graph with pos and filter.png|800px|Dependency tree of "The resulting graph after only displaying dependencies of type 'amod'.]]<br />
<br />
=== Batch Diagramming ===<br />
If this dependency visualization is done on a large scale, it would be tedious to run the program separately for each individual sentence in the corpus. To speed things up, I implemented an option to input a .txt file with a list of filenames. The autoglosser will take that list and generate a separate output file (containing Latex code) for each filename in the list. This makes large scale diagramming more efficient and only requires the user to construct one large file.<br />
<br />
== Hard-coded Parameters ==<br />
There were several design choices that I made because I thought they looked the best, but these can be changed with simple edits to the autoglosser.py file.<br />
<br />
=== Column/Row Spacing ===<br />
I added a default 0.2cm gap between columns (words) and a default 0.2ex gap between rows (only relevant when POS tags are visible).<br />
<br />
=== Word Spacing ===<br />
When there was a dependency between two consecutive words, the label was sometimes wider than the connecting arrow. To clean up the visual, I added an extra 0.5cm between columns whenever this occurred.<br />
<br />
=== Filename Format ===<br />
In my code, I hard-coded the program to take input files in the form "<label>_input.txt" and to create output files in the form "<label>_output.txt".<br />
<br />
== Usage ==<br />
Clone the github repository found [https://github.swarthmore.edu/ltarlin1/ling073-ltarlin1-autoglosser here]. The <code>autoglosser.py</code> file can be run with the following format: <code>python autoglosser.py [input file] [type] [POS tags] <dependencies to include - OPTIONAL></code>. Each of these arguments is explained in more detail below:<br />
* '''input file''': This argument specifies the CG file to be diagrammed. The code expects the name of the file to follow the form "<label>_input.txt", but this parameter only requires the label. For example, if the desired input file were "fox_input.txt", this argument would simply be "fox". The exception to this rule is if the user wants to do batch processing, in which case this argument is simply the name of the file containing the other filenames.<br />
* '''type''': This argument specifies whether the input file is a single sentence or a list of filenames. The options are "m" (for multiple, or batch processing) or "s" (for a single sentence).<br />
* '''POS tags''': This argument specifies whether the part-of-speech tags should be displayed below the text of the sentence. The options are "1" (for yes) or "0" (for no).<br />
* '''[OPTIONAL] Dependencies''' : This optional argument (or arguments) are the specific dependency types that should be displayed in the graph. If more than one is desired, simply list them here separated by spaces. For example, if you wanted to only see dependencies of type "det" and "amod", you would add "det amod" after the POS tag argument.<br />
<br />
== Evaluation ==<br />
I evaluated the quality of the autoglosser by the extent to which it accomplished the things I set out to accomplish. On a most basic level, the project goal was to provide an automatic way to visualize the syntactic dependencies of a sentence in Latex. Not only did my code do this, it provided additional customization to selectively view certain portions of the diagram. It also allowed for automatic batch processing to expedite the visualization process for a large corpus. Although there are still ways that the functionality of the autoglosser could be expanded and the aesthetics improved, the results that I got are what I hoped to produce for this final project.<br />
<br />
[[Category:sp17_FinalProjects]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Ltarlin1/Final_Project&diff=5308Ltarlin1/Final Project2017-05-10T06:43:40Z<p>Ltarlin1: /* Usage */</p>
<hr />
<div>== Code ==<br />
[https://github.swarthmore.edu/ltarlin1/ling073-ltarlin1-autoglosser Github link]<br />
<br />
== The Problem ==<br />
For my final project, I decided to create an autoglosser that would automatically convert the universal dependency files we worked with in class into visual form in Latex. There is a Latex package called tikz-dependency that allows for quick input of sentences and its corresponding dependencies, but it still requires the user to manually select each dependency. Therefore, my code automatically generates Latex code that fits the expected format for the tikz-dependency package and therefore can easily be displayed in a graph, as in the following example image:<br />
<br />
[[File:Lee-tikz-dependency.png|800px|Dependency tree of "An example output of the tikz-dependency latex package.]]<br />
<br />
Although this graph is fancy and colorful, the output of my code is a simplified version that includes all of the most relevant information and has some customizable features. A description of the code, the output, and how to run the program follows.<br />
<br />
== Previous Work ==<br />
As discussed in the above section, the tikz-dependency package uses the tikz interface to facilitate the graph-making process. The syntax of a dependency in this format is strikingly similar to that which we saw in class (i.e. #4->6) because both refer to the "from word" and the "to word" using offset from the beginning of the sentence, so it was relatively simple to translate from one form to another.<br />
<br />
== Who Will Benefit ==<br />
This tool would be useful for linguists who want to speed up the visual-making process when working with universal dependencies. It does not have much of an application outside the technical linguistics domain because generating the input files to my program requires prior knowledge of universal dependencies.<br />
<br />
== Basic Solution ==<br />
My autoglosser parses each line of the CG file and separates it into the relevant portions--the words that make up the sentence, each corresponding part of speech, the other side of the dependency, and the type of dependence relationship. The more specific part-of-speech information present in the CG file is ignored because it would clutter the sentence diagram if it were included.<br />
<br />
Therefore, a CG file like the one we looked at in class<br />
<pre><br />
"<The>"<br />
"The" det def sp @det #1->4<br />
"<quick>"<br />
"quick" adj sint @amod #2->4<br />
"<brown>"<br />
"brown" adj @amod #3->4<br />
"<fox>"<br />
"fox" n sg @nsubj #4->5<br />
"<jumps>"<br />
"jump" vblex pres p3 sg @root #5->0<br />
"<over>"<br />
"over" pr @case #6->9<br />
"<the>"<br />
"the" det def sp @det #7->9<br />
"<lazy>"<br />
"lazy" adj sint @amod #8->9<br />
"<dog>"<br />
"dog" n sg @obl #9->5<br />
"<in>"<br />
"in" pr @case #10->13<br />
"<the>"<br />
"the" det def sp @det #11->13<br />
"<green>"<br />
"green" adj sint @amod #12->13<br />
"<fields>"<br />
"field" n pl @obl #13->5<br />
"<.>"<br />
"." sent<br />
</pre><br />
<br />
is turned into something like this:<br />
<pre><br />
words = ['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog', 'in', 'the', 'green', 'fields', '.']<br />
<br />
info = [<br />
['"The"', 'det', 'def', 'sp', '@det', '#1->4'], <br />
['"quick"', 'adj', 'sint', '@amod', '#2->4'], <br />
['"brown"', 'adj', '@amod', '#3->4'], <br />
['"fox"', 'n', 'sg', '@nsubj', '#4->5'], <br />
['"jump"', 'vblex', 'pres', 'p3', 'sg', '@root', '#5->0'], <br />
['"over"', 'pr', '@case', '#6->9'], <br />
['"the"', 'det', 'def', 'sp', '@det', '#7->9'], <br />
['"lazy"', 'adj', 'sint', '@amod', '#8->9'], <br />
['"dog"', 'n', 'sg', '@obl', '#9->5'], <br />
['"in"', 'pr', '@case', '#10->13'], <br />
['"the"', 'det', 'def', 'sp', '@det', '#11->13'], <br />
['"green"', 'adj', 'sint', '@amod', '#12->13'], <br />
['"field"', 'n', 'pl', '@obl', '#13->5'], <br />
['"."', 'sent']]<br />
</pre><br />
<br />
The next step that my program takes is using string formatting to extract the relevant aspects of this "info"--namely the "from word", the "to word", and the type of dependency (indicated by the '@' symbol). Once I have all of this information, I can simply plug it into the corresponding locations in the desired format. Therefore, the final Latex code outputted by the simplest version of my program is<br />
<br />
<pre><br />
\begin{dependency}<br />
\begin{deptext}[column sep=0.2cm]<br />
The \& quick \& brown \& fox \& jumps \& over \& the \& lazy \& dog \& in \& the \& green \& fields \& ROOT \\ <br />
\end{deptext}<br />
\depedge{4}{1}{det}<br />
\depedge{4}{2}{amod}<br />
\depedge{4}{3}{amod}<br />
\depedge{5}{4}{nsubj}<br />
\depedge{14}{5}{root}<br />
\depedge{9}{6}{case}<br />
\depedge{9}{7}{det}<br />
\depedge{9}{8}{amod}<br />
\depedge{5}{9}{obl}<br />
\depedge{13}{10}{case}<br />
\depedge{13}{11}{det}<br />
\depedge{13}{12}{amod}<br />
\depedge{5}{13}{obl}<br />
\end{dependency}<br />
</pre><br />
<br />
Once you add the line <code>\usepackage{tikz-dependency}</code> to a blank Latex file, you can add this code and get the resulting image:<br />
<br />
[[File:example graph basic.png|800px|Dependency tree of "The resulting graph after running the original CG dependency file through my program.]]<br />
<br />
== More Complicated Solution ==<br />
I also added several customizable features to the program. I will briefly explain how each works here.<br />
<br />
=== Visible POS Tags ===<br />
I added the capability to display the part of speech tags below the text of the sentence. However, since this option may not always be desired, one of the command line arguments for the program toggles it on or off. This is the same graph as above, except with the POS tags visible:<br />
<br />
[[File:example graph with pos.png|800px|Dependency tree of "The resulting graph after setting the POS tags as visible.]]<br />
<br />
=== Dependency Filter ===<br />
In some situations, it may be useful to only view dependencies of a certain type. My tool allows you to optionally specify specific tag names that you want to appear in the graph. If no individual dependency types are listed, it will default to showing all of them. This is the same sentence as the previous examples, but this time with only the 'amod' dependencies displayed:<br />
<br />
[[File:example graph with pos and filter.png|800px|Dependency tree of "The resulting graph after only displaying dependencies of type 'amod'.]]<br />
<br />
=== Batch Diagramming ===<br />
If this dependency visualization is done on a large scale, it would be tedious to run the program separately for each individual sentence in the corpus. To speed things up, I implemented an option to input a .txt file with a list of filenames. The autoglosser will take that list and generate a separate output file (containing Latex code) for each filename in the list. This makes large scale diagramming more efficient and only requires the user to construct one large file.<br />
<br />
== Hard-coded Parameters ==<br />
There were several design choices that I made because I thought they looked the best, but these can be changed with simple edits to the autoglosser.py file.<br />
<br />
=== Column/Row Spacing ===<br />
I added a default 0.2cm gap between columns (words) and a default 0.2ex gap between rows (only relevant when POS tags are visible).<br />
<br />
=== Word Spacing ===<br />
When there was a dependency between two consecutive words, the label was sometimes wider than the connecting arrow. To clean up the visual, I added an extra 0.5cm between columns whenever this occurred.<br />
<br />
=== Filename Format ===<br />
In my code, I hard-coded the program to take input files in the form "<label>_input.txt" and to create output files in the form "<label>_output.txt".<br />
<br />
== Usage ==<br />
Clone the github repository found [https://github.swarthmore.edu/ltarlin1/ling073-ltarlin1-autoglosser here]. The <code>autoglosser.py</code> file can be run with the following format: <code>python autoglosser.py [input file] [type] [POS tags] <dependencies to include - OPTIONAL></code>. Each of these arguments is explained in more detail below:<br />
* '''input file''': This argument specifies the CG file to be diagrammed. The code expects the name of the file to follow the form "<label>_input.txt", but this parameter only requires the label. For example, if the desired input file were "fox_input.txt", this argument would simply be "fox". The exception to this rule is if the user wants to do batch processing, in which case this argument is simply the name of the file containing the other filenames.<br />
* '''type''': This argument specifies whether the input file is a single sentence or a list of filenames. The options are "m" (for multiple, or batch processing) or "s" (for a single sentence).<br />
* '''POS tags''': This argument specifies whether the part-of-speech tags should be displayed below the text of the sentence. The options are "1" (for yes) or "0" (for no).<br />
* '''[OPTIONAL] Dependencies''' : This optional argument (or arguments) are the specific dependency types that should be displayed in the graph. If more than one is desired, simply list them here separated by spaces. For example, if you wanted to only see dependencies of type "det" and "amod", you would add "det amod" after the POS tag argument.<br />
<br />
== Evaluation ==<br />
I evaluated the quality of the autoglosser by the extent to which it accomplished the things I set out to accomplish. On a most basic level, the project goal was to provide an automatic way to visualize the syntactic dependencies of a sentence in Latex. Not only did my code do this, it provided additional customization to selectively view certain portions of the diagram. It also allowed for automatic batch processing to expedite the visualization process for a large corpus. Although there are still ways that the functionality of the autoglosser could be expanded and the aesthetics improved, the results that I got are what I hoped to produce for this final project.<br />
<br />
[[Category:sp17_FinalProjects]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Ltarlin1/Final_Project&diff=5307Ltarlin1/Final Project2017-05-10T06:43:21Z<p>Ltarlin1: /* Usage */</p>
<hr />
<div>== Code ==<br />
[https://github.swarthmore.edu/ltarlin1/ling073-ltarlin1-autoglosser Github link]<br />
<br />
== The Problem ==<br />
For my final project, I decided to create an autoglosser that would automatically convert the universal dependency files we worked with in class into visual form in Latex. There is a Latex package called tikz-dependency that allows for quick input of sentences and its corresponding dependencies, but it still requires the user to manually select each dependency. Therefore, my code automatically generates Latex code that fits the expected format for the tikz-dependency package and therefore can easily be displayed in a graph, as in the following example image:<br />
<br />
[[File:Lee-tikz-dependency.png|800px|Dependency tree of "An example output of the tikz-dependency latex package.]]<br />
<br />
Although this graph is fancy and colorful, the output of my code is a simplified version that includes all of the most relevant information and has some customizable features. A description of the code, the output, and how to run the program follows.<br />
<br />
== Previous Work ==<br />
As discussed in the above section, the tikz-dependency package uses the tikz interface to facilitate the graph-making process. The syntax of a dependency in this format is strikingly similar to that which we saw in class (i.e. #4->6) because both refer to the "from word" and the "to word" using offset from the beginning of the sentence, so it was relatively simple to translate from one form to another.<br />
<br />
== Who Will Benefit ==<br />
This tool would be useful for linguists who want to speed up the visual-making process when working with universal dependencies. It does not have much of an application outside the technical linguistics domain because generating the input files to my program requires prior knowledge of universal dependencies.<br />
<br />
== Basic Solution ==<br />
My autoglosser parses each line of the CG file and separates it into the relevant portions--the words that make up the sentence, each corresponding part of speech, the other side of the dependency, and the type of dependence relationship. The more specific part-of-speech information present in the CG file is ignored because it would clutter the sentence diagram if it were included.<br />
<br />
Therefore, a CG file like the one we looked at in class<br />
<pre><br />
"<The>"<br />
"The" det def sp @det #1->4<br />
"<quick>"<br />
"quick" adj sint @amod #2->4<br />
"<brown>"<br />
"brown" adj @amod #3->4<br />
"<fox>"<br />
"fox" n sg @nsubj #4->5<br />
"<jumps>"<br />
"jump" vblex pres p3 sg @root #5->0<br />
"<over>"<br />
"over" pr @case #6->9<br />
"<the>"<br />
"the" det def sp @det #7->9<br />
"<lazy>"<br />
"lazy" adj sint @amod #8->9<br />
"<dog>"<br />
"dog" n sg @obl #9->5<br />
"<in>"<br />
"in" pr @case #10->13<br />
"<the>"<br />
"the" det def sp @det #11->13<br />
"<green>"<br />
"green" adj sint @amod #12->13<br />
"<fields>"<br />
"field" n pl @obl #13->5<br />
"<.>"<br />
"." sent<br />
</pre><br />
<br />
is turned into something like this:<br />
<pre><br />
words = ['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog', 'in', 'the', 'green', 'fields', '.']<br />
<br />
info = [<br />
['"The"', 'det', 'def', 'sp', '@det', '#1->4'], <br />
['"quick"', 'adj', 'sint', '@amod', '#2->4'], <br />
['"brown"', 'adj', '@amod', '#3->4'], <br />
['"fox"', 'n', 'sg', '@nsubj', '#4->5'], <br />
['"jump"', 'vblex', 'pres', 'p3', 'sg', '@root', '#5->0'], <br />
['"over"', 'pr', '@case', '#6->9'], <br />
['"the"', 'det', 'def', 'sp', '@det', '#7->9'], <br />
['"lazy"', 'adj', 'sint', '@amod', '#8->9'], <br />
['"dog"', 'n', 'sg', '@obl', '#9->5'], <br />
['"in"', 'pr', '@case', '#10->13'], <br />
['"the"', 'det', 'def', 'sp', '@det', '#11->13'], <br />
['"green"', 'adj', 'sint', '@amod', '#12->13'], <br />
['"field"', 'n', 'pl', '@obl', '#13->5'], <br />
['"."', 'sent']]<br />
</pre><br />
<br />
The next step that my program takes is using string formatting to extract the relevant aspects of this "info"--namely the "from word", the "to word", and the type of dependency (indicated by the '@' symbol). Once I have all of this information, I can simply plug it into the corresponding locations in the desired format. Therefore, the final Latex code outputted by the simplest version of my program is<br />
<br />
<pre><br />
\begin{dependency}<br />
\begin{deptext}[column sep=0.2cm]<br />
The \& quick \& brown \& fox \& jumps \& over \& the \& lazy \& dog \& in \& the \& green \& fields \& ROOT \\ <br />
\end{deptext}<br />
\depedge{4}{1}{det}<br />
\depedge{4}{2}{amod}<br />
\depedge{4}{3}{amod}<br />
\depedge{5}{4}{nsubj}<br />
\depedge{14}{5}{root}<br />
\depedge{9}{6}{case}<br />
\depedge{9}{7}{det}<br />
\depedge{9}{8}{amod}<br />
\depedge{5}{9}{obl}<br />
\depedge{13}{10}{case}<br />
\depedge{13}{11}{det}<br />
\depedge{13}{12}{amod}<br />
\depedge{5}{13}{obl}<br />
\end{dependency}<br />
</pre><br />
<br />
Once you add the line <code>\usepackage{tikz-dependency}</code> to a blank Latex file, you can add this code and get the resulting image:<br />
<br />
[[File:example graph basic.png|800px|Dependency tree of "The resulting graph after running the original CG dependency file through my program.]]<br />
<br />
== More Complicated Solution ==<br />
I also added several customizable features to the program. I will briefly explain how each works here.<br />
<br />
=== Visible POS Tags ===<br />
I added the capability to display the part of speech tags below the text of the sentence. However, since this option may not always be desired, one of the command line arguments for the program toggles it on or off. This is the same graph as above, except with the POS tags visible:<br />
<br />
[[File:example graph with pos.png|800px|Dependency tree of "The resulting graph after setting the POS tags as visible.]]<br />
<br />
=== Dependency Filter ===<br />
In some situations, it may be useful to only view dependencies of a certain type. My tool allows you to optionally specify specific tag names that you want to appear in the graph. If no individual dependency types are listed, it will default to showing all of them. This is the same sentence as the previous examples, but this time with only the 'amod' dependencies displayed:<br />
<br />
[[File:example graph with pos and filter.png|800px|Dependency tree of "The resulting graph after only displaying dependencies of type 'amod'.]]<br />
<br />
=== Batch Diagramming ===<br />
If this dependency visualization is done on a large scale, it would be tedious to run the program separately for each individual sentence in the corpus. To speed things up, I implemented an option to input a .txt file with a list of filenames. The autoglosser will take that list and generate a separate output file (containing Latex code) for each filename in the list. This makes large scale diagramming more efficient and only requires the user to construct one large file.<br />
<br />
== Hard-coded Parameters ==<br />
There were several design choices that I made because I thought they looked the best, but these can be changed with simple edits to the autoglosser.py file.<br />
<br />
=== Column/Row Spacing ===<br />
I added a default 0.2cm gap between columns (words) and a default 0.2ex gap between rows (only relevant when POS tags are visible).<br />
<br />
=== Word Spacing ===<br />
When there was a dependency between two consecutive words, the label was sometimes wider than the connecting arrow. To clean up the visual, I added an extra 0.5cm between columns whenever this occurred.<br />
<br />
=== Filename Format ===<br />
In my code, I hard-coded the program to take input files in the form "<label>_input.txt" and to create output files in the form "<label>_output.txt".<br />
<br />
== Usage ==<br />
Clone the github repository found [https://github.swarthmore.edu/ltarlin1/ling073-ltarlin1-autoglosser here]. The <code>autoglosser.py</code> file can be run with the following format: <code>python autoglosser.py [input file] [type] [POS tags] <dependencies to include - OPTIONAL></code>. Each of these arguments is explained in more detail below:<br />
* '''input file''': This argument specifies the CG file to be diagrammed. The code expects the name of the file to follow the form "<label>_input.txt", but this parameter only requires the label. For example, if the desired input file were "fox_input.txt", this argument would simply be "fox". The exception to this rule is if the user wants to do batch processing, in which case this argument is simply the name of the file containing the other filenames.<br />
* '''type''': This argument specifies whether the input file is a single sentence or a list of filenames. The options are "m" (for multiple, or batch processing) or "s" (for a single sentence).<br />
* '''POS tags''': This argument specifies whether the part-of-speech tags should be displayed below the text of the sentence. The options are "1" (for yes) or "0" (for no).<br />
* '''Dependencies [OPTIONAL]''' : This optional argument (or arguments) are the specific dependency types that should be displayed in the graph. If more than one is desired, simply list them here separated by spaces. For example, if you wanted to only see dependencies of type "det" and "amod", you would add "det amod" after the POS tag argument.<br />
<br />
== Evaluation ==<br />
I evaluated the quality of the autoglosser by the extent to which it accomplished the things I set out to accomplish. On a most basic level, the project goal was to provide an automatic way to visualize the syntactic dependencies of a sentence in Latex. Not only did my code do this, it provided additional customization to selectively view certain portions of the diagram. It also allowed for automatic batch processing to expedite the visualization process for a large corpus. Although there are still ways that the functionality of the autoglosser could be expanded and the aesthetics improved, the results that I got are what I hoped to produce for this final project.<br />
<br />
[[Category:sp17_FinalProjects]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Ltarlin1/Final_Project&diff=5306Ltarlin1/Final Project2017-05-10T06:41:54Z<p>Ltarlin1: /* Usage */</p>
<hr />
<div>== Code ==<br />
[https://github.swarthmore.edu/ltarlin1/ling073-ltarlin1-autoglosser Github link]<br />
<br />
== The Problem ==<br />
For my final project, I decided to create an autoglosser that would automatically convert the universal dependency files we worked with in class into visual form in Latex. There is a Latex package called tikz-dependency that allows for quick input of sentences and its corresponding dependencies, but it still requires the user to manually select each dependency. Therefore, my code automatically generates Latex code that fits the expected format for the tikz-dependency package and therefore can easily be displayed in a graph, as in the following example image:<br />
<br />
[[File:Lee-tikz-dependency.png|800px|Dependency tree of "An example output of the tikz-dependency latex package.]]<br />
<br />
Although this graph is fancy and colorful, the output of my code is a simplified version that includes all of the most relevant information and has some customizable features. A description of the code, the output, and how to run the program follows.<br />
<br />
== Previous Work ==<br />
As discussed in the above section, the tikz-dependency package uses the tikz interface to facilitate the graph-making process. The syntax of a dependency in this format is strikingly similar to that which we saw in class (i.e. #4->6) because both refer to the "from word" and the "to word" using offset from the beginning of the sentence, so it was relatively simple to translate from one form to another.<br />
<br />
== Who Will Benefit ==<br />
This tool would be useful for linguists who want to speed up the visual-making process when working with universal dependencies. It does not have much of an application outside the technical linguistics domain because generating the input files to my program requires prior knowledge of universal dependencies.<br />
<br />
== Basic Solution ==<br />
My autoglosser parses each line of the CG file and separates it into the relevant portions--the words that make up the sentence, each corresponding part of speech, the other side of the dependency, and the type of dependence relationship. The more specific part-of-speech information present in the CG file is ignored because it would clutter the sentence diagram if it were included.<br />
<br />
Therefore, a CG file like the one we looked at in class<br />
<pre><br />
"<The>"<br />
"The" det def sp @det #1->4<br />
"<quick>"<br />
"quick" adj sint @amod #2->4<br />
"<brown>"<br />
"brown" adj @amod #3->4<br />
"<fox>"<br />
"fox" n sg @nsubj #4->5<br />
"<jumps>"<br />
"jump" vblex pres p3 sg @root #5->0<br />
"<over>"<br />
"over" pr @case #6->9<br />
"<the>"<br />
"the" det def sp @det #7->9<br />
"<lazy>"<br />
"lazy" adj sint @amod #8->9<br />
"<dog>"<br />
"dog" n sg @obl #9->5<br />
"<in>"<br />
"in" pr @case #10->13<br />
"<the>"<br />
"the" det def sp @det #11->13<br />
"<green>"<br />
"green" adj sint @amod #12->13<br />
"<fields>"<br />
"field" n pl @obl #13->5<br />
"<.>"<br />
"." sent<br />
</pre><br />
<br />
is turned into something like this:<br />
<pre><br />
words = ['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog', 'in', 'the', 'green', 'fields', '.']<br />
<br />
info = [<br />
['"The"', 'det', 'def', 'sp', '@det', '#1->4'], <br />
['"quick"', 'adj', 'sint', '@amod', '#2->4'], <br />
['"brown"', 'adj', '@amod', '#3->4'], <br />
['"fox"', 'n', 'sg', '@nsubj', '#4->5'], <br />
['"jump"', 'vblex', 'pres', 'p3', 'sg', '@root', '#5->0'], <br />
['"over"', 'pr', '@case', '#6->9'], <br />
['"the"', 'det', 'def', 'sp', '@det', '#7->9'], <br />
['"lazy"', 'adj', 'sint', '@amod', '#8->9'], <br />
['"dog"', 'n', 'sg', '@obl', '#9->5'], <br />
['"in"', 'pr', '@case', '#10->13'], <br />
['"the"', 'det', 'def', 'sp', '@det', '#11->13'], <br />
['"green"', 'adj', 'sint', '@amod', '#12->13'], <br />
['"field"', 'n', 'pl', '@obl', '#13->5'], <br />
['"."', 'sent']]<br />
</pre><br />
<br />
The next step that my program takes is using string formatting to extract the relevant aspects of this "info"--namely the "from word", the "to word", and the type of dependency (indicated by the '@' symbol). Once I have all of this information, I can simply plug it into the corresponding locations in the desired format. Therefore, the final Latex code outputted by the simplest version of my program is<br />
<br />
<pre><br />
\begin{dependency}<br />
\begin{deptext}[column sep=0.2cm]<br />
The \& quick \& brown \& fox \& jumps \& over \& the \& lazy \& dog \& in \& the \& green \& fields \& ROOT \\ <br />
\end{deptext}<br />
\depedge{4}{1}{det}<br />
\depedge{4}{2}{amod}<br />
\depedge{4}{3}{amod}<br />
\depedge{5}{4}{nsubj}<br />
\depedge{14}{5}{root}<br />
\depedge{9}{6}{case}<br />
\depedge{9}{7}{det}<br />
\depedge{9}{8}{amod}<br />
\depedge{5}{9}{obl}<br />
\depedge{13}{10}{case}<br />
\depedge{13}{11}{det}<br />
\depedge{13}{12}{amod}<br />
\depedge{5}{13}{obl}<br />
\end{dependency}<br />
</pre><br />
<br />
Once you add the line <code>\usepackage{tikz-dependency}</code> to a blank Latex file, you can add this code and get the resulting image:<br />
<br />
[[File:example graph basic.png|800px|Dependency tree of "The resulting graph after running the original CG dependency file through my program.]]<br />
<br />
== More Complicated Solution ==<br />
I also added several customizable features to the program. I will briefly explain how each works here.<br />
<br />
=== Visible POS Tags ===<br />
I added the capability to display the part of speech tags below the text of the sentence. However, since this option may not always be desired, one of the command line arguments for the program toggles it on or off. This is the same graph as above, except with the POS tags visible:<br />
<br />
[[File:example graph with pos.png|800px|Dependency tree of "The resulting graph after setting the POS tags as visible.]]<br />
<br />
=== Dependency Filter ===<br />
In some situations, it may be useful to only view dependencies of a certain type. My tool allows you to optionally specify specific tag names that you want to appear in the graph. If no individual dependency types are listed, it will default to showing all of them. This is the same sentence as the previous examples, but this time with only the 'amod' dependencies displayed:<br />
<br />
[[File:example graph with pos and filter.png|800px|Dependency tree of "The resulting graph after only displaying dependencies of type 'amod'.]]<br />
<br />
=== Batch Diagramming ===<br />
If this dependency visualization is done on a large scale, it would be tedious to run the program separately for each individual sentence in the corpus. To speed things up, I implemented an option to input a .txt file with a list of filenames. The autoglosser will take that list and generate a separate output file (containing Latex code) for each filename in the list. This makes large scale diagramming more efficient and only requires the user to construct one large file.<br />
<br />
== Hard-coded Parameters ==<br />
There were several design choices that I made because I thought they looked the best, but these can be changed with simple edits to the autoglosser.py file.<br />
<br />
=== Column/Row Spacing ===<br />
I added a default 0.2cm gap between columns (words) and a default 0.2ex gap between rows (only relevant when POS tags are visible).<br />
<br />
=== Word Spacing ===<br />
When there was a dependency between two consecutive words, the label was sometimes wider than the connecting arrow. To clean up the visual, I added an extra 0.5cm between columns whenever this occurred.<br />
<br />
=== Filename Format ===<br />
In my code, I hard-coded the program to take input files in the form "<label>_input.txt" and to create output files in the form "<label>_output.txt".<br />
<br />
== Usage ==<br />
Clone the github repository found [https://github.swarthmore.edu/ltarlin1/ling073-ltarlin1-autoglosser here]. The <code>autoglosser.py</code> file can be run with the following format: <code>python autoglosser.py [input file] [type] [POS tags] <dependencies to include - OPTIONAL></code>. Each of these arguments is explained in more detail below:<br />
* '''input file''': This argument specifies the CG file to be diagrammed. The code expects the name of the file to follow the form "<label>_input.txt", but this parameter only requires the label. For example, if the desired input file were "fox_input.txt", this argument would simply be "fox". The exception to this rule is if the user wants to do batch processing, in which case this argument is simply the name of the file containing the other filenames.<br />
* '''type''': This argument specifies whether the input file is a single sentence or a list of filenames. The options are "m" (for multiple, or batch processing) or "s" (for a single sentence).<br />
* '''POS tags''': This argument specifies whether the part-of-speech tags should be displayed below the text of the sentence. The options are "1" (for yes) or "0" (for no).<br />
* '''Dependencies <optional>''' : This optional argument (or arguments) are the specific dependency types that should be displayed in the graph. If more than one is desired, simply list them here separated by spaces. For example, if you wanted to only see dependencies of type "det" and "amod", you would add "det amod" after the POS tag argument.<br />
<br />
== Evaluation ==<br />
I evaluated the quality of the autoglosser by the extent to which it accomplished the things I set out to accomplish. On a most basic level, the project goal was to provide an automatic way to visualize the syntactic dependencies of a sentence in Latex. Not only did my code do this, it provided additional customization to selectively view certain portions of the diagram. It also allowed for automatic batch processing to expedite the visualization process for a large corpus. Although there are still ways that the functionality of the autoglosser could be expanded and the aesthetics improved, the results that I got are what I hoped to produce for this final project.<br />
<br />
[[Category:sp17_FinalProjects]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Ltarlin1/Final_Project&diff=5305Ltarlin1/Final Project2017-05-10T06:41:36Z<p>Ltarlin1: /* Usage */</p>
<hr />
<div>== Code ==<br />
[https://github.swarthmore.edu/ltarlin1/ling073-ltarlin1-autoglosser Github link]<br />
<br />
== The Problem ==<br />
For my final project, I decided to create an autoglosser that would automatically convert the universal dependency files we worked with in class into visual form in Latex. There is a Latex package called tikz-dependency that allows for quick input of sentences and its corresponding dependencies, but it still requires the user to manually select each dependency. Therefore, my code automatically generates Latex code that fits the expected format for the tikz-dependency package and therefore can easily be displayed in a graph, as in the following example image:<br />
<br />
[[File:Lee-tikz-dependency.png|800px|Dependency tree of "An example output of the tikz-dependency latex package.]]<br />
<br />
Although this graph is fancy and colorful, the output of my code is a simplified version that includes all of the most relevant information and has some customizable features. A description of the code, the output, and how to run the program follows.<br />
<br />
== Previous Work ==<br />
As discussed in the above section, the tikz-dependency package uses the tikz interface to facilitate the graph-making process. The syntax of a dependency in this format is strikingly similar to that which we saw in class (i.e. #4->6) because both refer to the "from word" and the "to word" using offset from the beginning of the sentence, so it was relatively simple to translate from one form to another.<br />
<br />
== Who Will Benefit ==<br />
This tool would be useful for linguists who want to speed up the visual-making process when working with universal dependencies. It does not have much of an application outside the technical linguistics domain because generating the input files to my program requires prior knowledge of universal dependencies.<br />
<br />
== Basic Solution ==<br />
My autoglosser parses each line of the CG file and separates it into the relevant portions--the words that make up the sentence, each corresponding part of speech, the other side of the dependency, and the type of dependence relationship. The more specific part-of-speech information present in the CG file is ignored because it would clutter the sentence diagram if it were included.<br />
<br />
Therefore, a CG file like the one we looked at in class<br />
<pre><br />
"<The>"<br />
"The" det def sp @det #1->4<br />
"<quick>"<br />
"quick" adj sint @amod #2->4<br />
"<brown>"<br />
"brown" adj @amod #3->4<br />
"<fox>"<br />
"fox" n sg @nsubj #4->5<br />
"<jumps>"<br />
"jump" vblex pres p3 sg @root #5->0<br />
"<over>"<br />
"over" pr @case #6->9<br />
"<the>"<br />
"the" det def sp @det #7->9<br />
"<lazy>"<br />
"lazy" adj sint @amod #8->9<br />
"<dog>"<br />
"dog" n sg @obl #9->5<br />
"<in>"<br />
"in" pr @case #10->13<br />
"<the>"<br />
"the" det def sp @det #11->13<br />
"<green>"<br />
"green" adj sint @amod #12->13<br />
"<fields>"<br />
"field" n pl @obl #13->5<br />
"<.>"<br />
"." sent<br />
</pre><br />
<br />
is turned into something like this:<br />
<pre><br />
words = ['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog', 'in', 'the', 'green', 'fields', '.']<br />
<br />
info = [<br />
['"The"', 'det', 'def', 'sp', '@det', '#1->4'], <br />
['"quick"', 'adj', 'sint', '@amod', '#2->4'], <br />
['"brown"', 'adj', '@amod', '#3->4'], <br />
['"fox"', 'n', 'sg', '@nsubj', '#4->5'], <br />
['"jump"', 'vblex', 'pres', 'p3', 'sg', '@root', '#5->0'], <br />
['"over"', 'pr', '@case', '#6->9'], <br />
['"the"', 'det', 'def', 'sp', '@det', '#7->9'], <br />
['"lazy"', 'adj', 'sint', '@amod', '#8->9'], <br />
['"dog"', 'n', 'sg', '@obl', '#9->5'], <br />
['"in"', 'pr', '@case', '#10->13'], <br />
['"the"', 'det', 'def', 'sp', '@det', '#11->13'], <br />
['"green"', 'adj', 'sint', '@amod', '#12->13'], <br />
['"field"', 'n', 'pl', '@obl', '#13->5'], <br />
['"."', 'sent']]<br />
</pre><br />
<br />
The next step that my program takes is using string formatting to extract the relevant aspects of this "info"--namely the "from word", the "to word", and the type of dependency (indicated by the '@' symbol). Once I have all of this information, I can simply plug it into the corresponding locations in the desired format. Therefore, the final Latex code outputted by the simplest version of my program is<br />
<br />
<pre><br />
\begin{dependency}<br />
\begin{deptext}[column sep=0.2cm]<br />
The \& quick \& brown \& fox \& jumps \& over \& the \& lazy \& dog \& in \& the \& green \& fields \& ROOT \\ <br />
\end{deptext}<br />
\depedge{4}{1}{det}<br />
\depedge{4}{2}{amod}<br />
\depedge{4}{3}{amod}<br />
\depedge{5}{4}{nsubj}<br />
\depedge{14}{5}{root}<br />
\depedge{9}{6}{case}<br />
\depedge{9}{7}{det}<br />
\depedge{9}{8}{amod}<br />
\depedge{5}{9}{obl}<br />
\depedge{13}{10}{case}<br />
\depedge{13}{11}{det}<br />
\depedge{13}{12}{amod}<br />
\depedge{5}{13}{obl}<br />
\end{dependency}<br />
</pre><br />
<br />
Once you add the line <code>\usepackage{tikz-dependency}</code> to a blank Latex file, you can add this code and get the resulting image:<br />
<br />
[[File:example graph basic.png|800px|Dependency tree of "The resulting graph after running the original CG dependency file through my program.]]<br />
<br />
== More Complicated Solution ==<br />
I also added several customizable features to the program. I will briefly explain how each works here.<br />
<br />
=== Visible POS Tags ===<br />
I added the capability to display the part of speech tags below the text of the sentence. However, since this option may not always be desired, one of the command line arguments for the program toggles it on or off. This is the same graph as above, except with the POS tags visible:<br />
<br />
[[File:example graph with pos.png|800px|Dependency tree of "The resulting graph after setting the POS tags as visible.]]<br />
<br />
=== Dependency Filter ===<br />
In some situations, it may be useful to only view dependencies of a certain type. My tool allows you to optionally specify specific tag names that you want to appear in the graph. If no individual dependency types are listed, it will default to showing all of them. This is the same sentence as the previous examples, but this time with only the 'amod' dependencies displayed:<br />
<br />
[[File:example graph with pos and filter.png|800px|Dependency tree of "The resulting graph after only displaying dependencies of type 'amod'.]]<br />
<br />
=== Batch Diagramming ===<br />
If this dependency visualization is done on a large scale, it would be tedious to run the program separately for each individual sentence in the corpus. To speed things up, I implemented an option to input a .txt file with a list of filenames. The autoglosser will take that list and generate a separate output file (containing Latex code) for each filename in the list. This makes large scale diagramming more efficient and only requires the user to construct one large file.<br />
<br />
== Hard-coded Parameters ==<br />
There were several design choices that I made because I thought they looked the best, but these can be changed with simple edits to the autoglosser.py file.<br />
<br />
=== Column/Row Spacing ===<br />
I added a default 0.2cm gap between columns (words) and a default 0.2ex gap between rows (only relevant when POS tags are visible).<br />
<br />
=== Word Spacing ===<br />
When there was a dependency between two consecutive words, the label was sometimes wider than the connecting arrow. To clean up the visual, I added an extra 0.5cm between columns whenever this occurred.<br />
<br />
=== Filename Format ===<br />
In my code, I hard-coded the program to take input files in the form "<label>_input.txt" and to create output files in the form "<label>_output.txt".<br />
<br />
== Usage ==<br />
Clone the github repository found [https://github.swarthmore.edu/ltarlin1/ling073-ltarlin1-autoglosser here]. The <code>autoglosser.py</code> file can be run with the following format: <code>python autoglosser.py [input file] [type] [POS tags] <dependencies to include - OPTIONAL></code>. Each of these arguments is explained in more detail below:<br />
* '''input file''' : This argument specifies the CG file to be diagrammed. The code expects the name of the file to follow the form "<label>_input.txt", but this parameter only requires the label. For example, if the desired input file were "fox_input.txt", this argument would simply be "fox". The exception to this rule is if the user wants to do batch processing, in which case this argument is simply the name of the file containing the other filenames.<br />
* '''type''' : This argument specifies whether the input file is a single sentence or a list of filenames. The options are "m" (for multiple, or batch processing) or "s" (for a single sentence).<br />
* '''POS tags''' : This argument specifies whether the part-of-speech tags should be displayed below the text of the sentence. The options are "1" (for yes) or "0" (for no).<br />
* '''Dependencies <optional>''' : This optional argument (or arguments) are the specific dependency types that should be displayed in the graph. If more than one is desired, simply list them here separated by spaces. For example, if you wanted to only see dependencies of type "det" and "amod", you would add "det amod" after the POS tag argument.<br />
<br />
== Evaluation ==<br />
I evaluated the quality of the autoglosser by the extent to which it accomplished the things I set out to accomplish. On a most basic level, the project goal was to provide an automatic way to visualize the syntactic dependencies of a sentence in Latex. Not only did my code do this, it provided additional customization to selectively view certain portions of the diagram. It also allowed for automatic batch processing to expedite the visualization process for a large corpus. Although there are still ways that the functionality of the autoglosser could be expanded and the aesthetics improved, the results that I got are what I hoped to produce for this final project.<br />
<br />
[[Category:sp17_FinalProjects]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Ltarlin1/Final_Project&diff=5304Ltarlin1/Final Project2017-05-10T06:40:55Z<p>Ltarlin1: </p>
<hr />
<div>== Code ==<br />
[https://github.swarthmore.edu/ltarlin1/ling073-ltarlin1-autoglosser Github link]<br />
<br />
== The Problem ==<br />
For my final project, I decided to create an autoglosser that would automatically convert the universal dependency files we worked with in class into visual form in Latex. There is a Latex package called tikz-dependency that allows for quick input of sentences and its corresponding dependencies, but it still requires the user to manually select each dependency. Therefore, my code automatically generates Latex code that fits the expected format for the tikz-dependency package and therefore can easily be displayed in a graph, as in the following example image:<br />
<br />
[[File:Lee-tikz-dependency.png|800px|Dependency tree of "An example output of the tikz-dependency latex package.]]<br />
<br />
Although this graph is fancy and colorful, the output of my code is a simplified version that includes all of the most relevant information and has some customizable features. A description of the code, the output, and how to run the program follows.<br />
<br />
== Previous Work ==<br />
As discussed in the above section, the tikz-dependency package uses the tikz interface to facilitate the graph-making process. The syntax of a dependency in this format is strikingly similar to that which we saw in class (i.e. #4->6) because both refer to the "from word" and the "to word" using offset from the beginning of the sentence, so it was relatively simple to translate from one form to another.<br />
<br />
== Who Will Benefit ==<br />
This tool would be useful for linguists who want to speed up the visual-making process when working with universal dependencies. It does not have much of an application outside the technical linguistics domain because generating the input files to my program requires prior knowledge of universal dependencies.<br />
<br />
== Basic Solution ==<br />
My autoglosser parses each line of the CG file and separates it into the relevant portions--the words that make up the sentence, each corresponding part of speech, the other side of the dependency, and the type of dependence relationship. The more specific part-of-speech information present in the CG file is ignored because it would clutter the sentence diagram if it were included.<br />
<br />
Therefore, a CG file like the one we looked at in class<br />
<pre><br />
"<The>"<br />
"The" det def sp @det #1->4<br />
"<quick>"<br />
"quick" adj sint @amod #2->4<br />
"<brown>"<br />
"brown" adj @amod #3->4<br />
"<fox>"<br />
"fox" n sg @nsubj #4->5<br />
"<jumps>"<br />
"jump" vblex pres p3 sg @root #5->0<br />
"<over>"<br />
"over" pr @case #6->9<br />
"<the>"<br />
"the" det def sp @det #7->9<br />
"<lazy>"<br />
"lazy" adj sint @amod #8->9<br />
"<dog>"<br />
"dog" n sg @obl #9->5<br />
"<in>"<br />
"in" pr @case #10->13<br />
"<the>"<br />
"the" det def sp @det #11->13<br />
"<green>"<br />
"green" adj sint @amod #12->13<br />
"<fields>"<br />
"field" n pl @obl #13->5<br />
"<.>"<br />
"." sent<br />
</pre><br />
<br />
is turned into something like this:<br />
<pre><br />
words = ['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog', 'in', 'the', 'green', 'fields', '.']<br />
<br />
info = [<br />
['"The"', 'det', 'def', 'sp', '@det', '#1->4'], <br />
['"quick"', 'adj', 'sint', '@amod', '#2->4'], <br />
['"brown"', 'adj', '@amod', '#3->4'], <br />
['"fox"', 'n', 'sg', '@nsubj', '#4->5'], <br />
['"jump"', 'vblex', 'pres', 'p3', 'sg', '@root', '#5->0'], <br />
['"over"', 'pr', '@case', '#6->9'], <br />
['"the"', 'det', 'def', 'sp', '@det', '#7->9'], <br />
['"lazy"', 'adj', 'sint', '@amod', '#8->9'], <br />
['"dog"', 'n', 'sg', '@obl', '#9->5'], <br />
['"in"', 'pr', '@case', '#10->13'], <br />
['"the"', 'det', 'def', 'sp', '@det', '#11->13'], <br />
['"green"', 'adj', 'sint', '@amod', '#12->13'], <br />
['"field"', 'n', 'pl', '@obl', '#13->5'], <br />
['"."', 'sent']]<br />
</pre><br />
<br />
The next step that my program takes is using string formatting to extract the relevant aspects of this "info"--namely the "from word", the "to word", and the type of dependency (indicated by the '@' symbol). Once I have all of this information, I can simply plug it into the corresponding locations in the desired format. Therefore, the final Latex code outputted by the simplest version of my program is<br />
<br />
<pre><br />
\begin{dependency}<br />
\begin{deptext}[column sep=0.2cm]<br />
The \& quick \& brown \& fox \& jumps \& over \& the \& lazy \& dog \& in \& the \& green \& fields \& ROOT \\ <br />
\end{deptext}<br />
\depedge{4}{1}{det}<br />
\depedge{4}{2}{amod}<br />
\depedge{4}{3}{amod}<br />
\depedge{5}{4}{nsubj}<br />
\depedge{14}{5}{root}<br />
\depedge{9}{6}{case}<br />
\depedge{9}{7}{det}<br />
\depedge{9}{8}{amod}<br />
\depedge{5}{9}{obl}<br />
\depedge{13}{10}{case}<br />
\depedge{13}{11}{det}<br />
\depedge{13}{12}{amod}<br />
\depedge{5}{13}{obl}<br />
\end{dependency}<br />
</pre><br />
<br />
Once you add the line <code>\usepackage{tikz-dependency}</code> to a blank Latex file, you can add this code and get the resulting image:<br />
<br />
[[File:example graph basic.png|800px|Dependency tree of "The resulting graph after running the original CG dependency file through my program.]]<br />
<br />
== More Complicated Solution ==<br />
I also added several customizable features to the program. I will briefly explain how each works here.<br />
<br />
=== Visible POS Tags ===<br />
I added the capability to display the part of speech tags below the text of the sentence. However, since this option may not always be desired, one of the command line arguments for the program toggles it on or off. This is the same graph as above, except with the POS tags visible:<br />
<br />
[[File:example graph with pos.png|800px|Dependency tree of "The resulting graph after setting the POS tags as visible.]]<br />
<br />
=== Dependency Filter ===<br />
In some situations, it may be useful to only view dependencies of a certain type. My tool allows you to optionally specify specific tag names that you want to appear in the graph. If no individual dependency types are listed, it will default to showing all of them. This is the same sentence as the previous examples, but this time with only the 'amod' dependencies displayed:<br />
<br />
[[File:example graph with pos and filter.png|800px|Dependency tree of "The resulting graph after only displaying dependencies of type 'amod'.]]<br />
<br />
=== Batch Diagramming ===<br />
If this dependency visualization is done on a large scale, it would be tedious to run the program separately for each individual sentence in the corpus. To speed things up, I implemented an option to input a .txt file with a list of filenames. The autoglosser will take that list and generate a separate output file (containing Latex code) for each filename in the list. This makes large scale diagramming more efficient and only requires the user to construct one large file.<br />
<br />
== Hard-coded Parameters ==<br />
There were several design choices that I made because I thought they looked the best, but these can be changed with simple edits to the autoglosser.py file.<br />
<br />
=== Column/Row Spacing ===<br />
I added a default 0.2cm gap between columns (words) and a default 0.2ex gap between rows (only relevant when POS tags are visible).<br />
<br />
=== Word Spacing ===<br />
When there was a dependency between two consecutive words, the label was sometimes wider than the connecting arrow. To clean up the visual, I added an extra 0.5cm between columns whenever this occurred.<br />
<br />
=== Filename Format ===<br />
In my code, I hard-coded the program to take input files in the form "<label>_input.txt" and to create output files in the form "<label>_output.txt".<br />
<br />
== Usage ==<br />
<ol><br />
<li>Clone the github repository found [https://github.swarthmore.edu/ltarlin1/ling073-ltarlin1-autoglosser here]<br />
<li>The <code>autoglosser.py</code> file can be run with the following format: <code>python autoglosser.py [input file] [type] [POS tags] <dependencies to include - OPTIONAL></code>. Each of these arguments is explained in more detail below:<br />
* '''input file''' : This argument specifies the CG file to be diagrammed. The code expects the name of the file to follow the form "<label>_input.txt", but this parameter only requires the label. For example, if the desired input file were "fox_input.txt", this argument would simply be "fox". The exception to this rule is if the user wants to do batch processing, in which case this argument is simply the name of the file containing the other filenames.<br />
* '''type''' : This argument specifies whether the input file is a single sentence or a list of filenames. The options are "m" (for multiple, or batch processing) or "s" (for a single sentence).<br />
* '''POS tags''' : This argument specifies whether the part-of-speech tags should be displayed below the text of the sentence. The options are "1" (for yes) or "0" (for no).<br />
* '''Dependencies <optional>''' : This optional argument (or arguments) are the specific dependency types that should be displayed in the graph. If more than one is desired, simply list them here separated by spaces. For example, if you wanted to only see dependencies of type "det" and "amod", you would add "det amod" after the POS tag argument.<br />
<ol><br />
<br />
<br />
== Evaluation ==<br />
I evaluated the quality of the autoglosser by the extent to which it accomplished the things I set out to accomplish. On a most basic level, the project goal was to provide an automatic way to visualize the syntactic dependencies of a sentence in Latex. Not only did my code do this, it provided additional customization to selectively view certain portions of the diagram. It also allowed for automatic batch processing to expedite the visualization process for a large corpus. Although there are still ways that the functionality of the autoglosser could be expanded and the aesthetics improved, the results that I got are what I hoped to produce for this final project.<br />
<br />
[[Category:sp17_FinalProjects]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Ltarlin1/Final_Project&diff=5303Ltarlin1/Final Project2017-05-10T06:22:13Z<p>Ltarlin1: /* Users */</p>
<hr />
<div>== Code ==<br />
[https://github.swarthmore.edu/ltarlin1/ling073-ltarlin1-autoglosser Github link]<br />
<br />
== The Problem ==<br />
For my final project, I decided to create an autoglosser that would automatically convert the universal dependency files we worked with in class into visual form in Latex. There is a Latex package called tikz-dependency that allows for quick input of sentences and its corresponding dependencies, but it still requires the user to manually select each dependency. Therefore, my code automatically generates Latex code that fits the expected format for the tikz-dependency package and therefore can easily be displayed in a graph, as in the following example image:<br />
<br />
[[File:Lee-tikz-dependency.png|800px|Dependency tree of "An example output of the tikz-dependency latex package.]]<br />
<br />
Although this graph is fancy and colorful, the output of my code is a simplified version that includes all of the most relevant information and has some customizable features. A description of the code, the output, and how to run the program follows.<br />
<br />
== Previous Work ==<br />
As discussed in the above section, the tikz-dependency package uses the tikz interface to facilitate the graph-making process. The syntax of a dependency in this format is strikingly similar to that which we saw in class (i.e. #4->6) because both refer to the "from word" and the "to word" using offset from the beginning of the sentence, so it was relatively simple to translate from one form to another.<br />
<br />
== Who Will Benefit ==<br />
This tool would be useful for linguists who want to speed up the visual-making process when working with universal dependencies. It does not have much of an application outside the technical linguistics domain because generating the input files to my program requires prior knowledge of universal dependencies.<br />
<br />
== Basic Solution ==<br />
My autoglosser parses each line of the CG file and separates it into the relevant portions--the words that make up the sentence, each corresponding part of speech, the other side of the dependency, and the type of dependence relationship. The more specific part-of-speech information present in the CG file is ignored because it would clutter the sentence diagram if it were included.<br />
<br />
Therefore, a CG file like the one we looked at in class<br />
<pre><br />
"<The>"<br />
"The" det def sp @det #1->4<br />
"<quick>"<br />
"quick" adj sint @amod #2->4<br />
"<brown>"<br />
"brown" adj @amod #3->4<br />
"<fox>"<br />
"fox" n sg @nsubj #4->5<br />
"<jumps>"<br />
"jump" vblex pres p3 sg @root #5->0<br />
"<over>"<br />
"over" pr @case #6->9<br />
"<the>"<br />
"the" det def sp @det #7->9<br />
"<lazy>"<br />
"lazy" adj sint @amod #8->9<br />
"<dog>"<br />
"dog" n sg @obl #9->5<br />
"<in>"<br />
"in" pr @case #10->13<br />
"<the>"<br />
"the" det def sp @det #11->13<br />
"<green>"<br />
"green" adj sint @amod #12->13<br />
"<fields>"<br />
"field" n pl @obl #13->5<br />
"<.>"<br />
"." sent<br />
</pre><br />
<br />
is turned into something like this:<br />
<pre><br />
words = ['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog', 'in', 'the', 'green', 'fields', '.']<br />
<br />
info = [<br />
['"The"', 'det', 'def', 'sp', '@det', '#1->4'], <br />
['"quick"', 'adj', 'sint', '@amod', '#2->4'], <br />
['"brown"', 'adj', '@amod', '#3->4'], <br />
['"fox"', 'n', 'sg', '@nsubj', '#4->5'], <br />
['"jump"', 'vblex', 'pres', 'p3', 'sg', '@root', '#5->0'], <br />
['"over"', 'pr', '@case', '#6->9'], <br />
['"the"', 'det', 'def', 'sp', '@det', '#7->9'], <br />
['"lazy"', 'adj', 'sint', '@amod', '#8->9'], <br />
['"dog"', 'n', 'sg', '@obl', '#9->5'], <br />
['"in"', 'pr', '@case', '#10->13'], <br />
['"the"', 'det', 'def', 'sp', '@det', '#11->13'], <br />
['"green"', 'adj', 'sint', '@amod', '#12->13'], <br />
['"field"', 'n', 'pl', '@obl', '#13->5'], <br />
['"."', 'sent']]<br />
</pre><br />
<br />
The next step that my program takes is using string formatting to extract the relevant aspects of this "info"--namely the "from word", the "to word", and the type of dependency (indicated by the '@' symbol). Once I have all of this information, I can simply plug it into the corresponding locations in the desired format. Therefore, the final Latex code outputted by the simplest version of my program is<br />
<br />
<pre><br />
\begin{dependency}<br />
\begin{deptext}[column sep=0.2cm]<br />
The \& quick \& brown \& fox \& jumps \& over \& the \& lazy \& dog \& in \& the \& green \& fields \& ROOT \\ <br />
\end{deptext}<br />
\depedge{4}{1}{det}<br />
\depedge{4}{2}{amod}<br />
\depedge{4}{3}{amod}<br />
\depedge{5}{4}{nsubj}<br />
\depedge{14}{5}{root}<br />
\depedge{9}{6}{case}<br />
\depedge{9}{7}{det}<br />
\depedge{9}{8}{amod}<br />
\depedge{5}{9}{obl}<br />
\depedge{13}{10}{case}<br />
\depedge{13}{11}{det}<br />
\depedge{13}{12}{amod}<br />
\depedge{5}{13}{obl}<br />
\end{dependency}<br />
</pre><br />
<br />
Once you add the line <code>\usepackage{tikz-dependency}</code> to a blank Latex file, you can add this code and get the resulting image:<br />
<br />
[[File:example graph basic.png|800px|Dependency tree of "The resulting graph after running the original CG dependency file through my program.]]<br />
<br />
== More Complicated Solution ==<br />
I also added several customizable features to the program. I will briefly explain how each works here.<br />
<br />
=== Visible POS Tags ===<br />
I added the capability to display the part of speech tags below the text of the sentence. However, since this option may not always be desired, one of the command line arguments for the program toggles it on or off. This is the same graph as above, except with the POS tags visible:<br />
<br />
[[File:example graph with pos.png|800px|Dependency tree of "The resulting graph after setting the POS tags as visible.]]<br />
<br />
=== Dependency Filter ===<br />
In some situations, it may be useful to only view dependencies of a certain type. My tool allows you to optionally specify specific tag names that you want to appear in the graph. If no individual dependency types are listed, it will default to showing all of them. This is the same sentence as the previous examples, but this time with only the 'amod' dependencies displayed:<br />
<br />
[[File:example graph with pos and filter.png|800px|Dependency tree of "The resulting graph after only displaying dependencies of type 'amod'.]]<br />
<br />
=== Batch Diagramming ===<br />
If this dependency visualization is done on a large scale, it would be tedious to run the program separately for each individual sentence in the corpus. To speed things up, I implemented an option to input a .txt file with a list of filenames. The autoglosser will take that list and generate a separate output file (containing Latex code) for each filename in the list. This makes large scale diagramming more efficient and only requires the user to construct one large file.<br />
<br />
== Hard-coded Parameters ==<br />
There were several design choices that I made because I thought they looked the best, but these can be changed with simple edits to the autoglosser.py file.<br />
<br />
=== Column/Row Spacing ===<br />
I added a default 0.2cm gap between columns (words) and a default 0.2ex gap between rows (only relevant when POS tags are visible).<br />
<br />
=== Word Spacing ===<br />
When there was a dependency between two consecutive words, the label was sometimes wider than the connecting arrow. To clean up the visual, I added an extra 0.5cm between columns whenever this occurred.<br />
<br />
=== Filename Format ===<br />
In my code, I hard-coded the program to take input files in the form "<label>_input.txt" and to create output files in the form "<label>_output.txt".<br />
<br />
== Evaluation ==<br />
it works, i promise<br />
<br />
<br />
[[Category:sp17_FinalProjects]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Ltarlin1/Final_Project&diff=5302Ltarlin1/Final Project2017-05-10T06:21:52Z<p>Ltarlin1: </p>
<hr />
<div>== Code ==<br />
[https://github.swarthmore.edu/ltarlin1/ling073-ltarlin1-autoglosser Github link]<br />
<br />
== The Problem ==<br />
For my final project, I decided to create an autoglosser that would automatically convert the universal dependency files we worked with in class into visual form in Latex. There is a Latex package called tikz-dependency that allows for quick input of sentences and its corresponding dependencies, but it still requires the user to manually select each dependency. Therefore, my code automatically generates Latex code that fits the expected format for the tikz-dependency package and therefore can easily be displayed in a graph, as in the following example image:<br />
<br />
[[File:Lee-tikz-dependency.png|800px|Dependency tree of "An example output of the tikz-dependency latex package.]]<br />
<br />
Although this graph is fancy and colorful, the output of my code is a simplified version that includes all of the most relevant information and has some customizable features. A description of the code, the output, and how to run the program follows.<br />
<br />
== Previous Work ==<br />
As discussed in the above section, the tikz-dependency package uses the tikz interface to facilitate the graph-making process. The syntax of a dependency in this format is strikingly similar to that which we saw in class (i.e. #4->6) because both refer to the "from word" and the "to word" using offset from the beginning of the sentence, so it was relatively simple to translate from one form to another.<br />
<br />
== Users ==<br />
This tool would be useful for linguists who want to speed up the visual-making process when working with universal dependencies. It does not have much of an application outside the technical linguistics domain because generating the input files to my program requires prior knowledge of universal dependencies.<br />
<br />
== Basic Solution ==<br />
My autoglosser parses each line of the CG file and separates it into the relevant portions--the words that make up the sentence, each corresponding part of speech, the other side of the dependency, and the type of dependence relationship. The more specific part-of-speech information present in the CG file is ignored because it would clutter the sentence diagram if it were included.<br />
<br />
Therefore, a CG file like the one we looked at in class<br />
<pre><br />
"<The>"<br />
"The" det def sp @det #1->4<br />
"<quick>"<br />
"quick" adj sint @amod #2->4<br />
"<brown>"<br />
"brown" adj @amod #3->4<br />
"<fox>"<br />
"fox" n sg @nsubj #4->5<br />
"<jumps>"<br />
"jump" vblex pres p3 sg @root #5->0<br />
"<over>"<br />
"over" pr @case #6->9<br />
"<the>"<br />
"the" det def sp @det #7->9<br />
"<lazy>"<br />
"lazy" adj sint @amod #8->9<br />
"<dog>"<br />
"dog" n sg @obl #9->5<br />
"<in>"<br />
"in" pr @case #10->13<br />
"<the>"<br />
"the" det def sp @det #11->13<br />
"<green>"<br />
"green" adj sint @amod #12->13<br />
"<fields>"<br />
"field" n pl @obl #13->5<br />
"<.>"<br />
"." sent<br />
</pre><br />
<br />
is turned into something like this:<br />
<pre><br />
words = ['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog', 'in', 'the', 'green', 'fields', '.']<br />
<br />
info = [<br />
['"The"', 'det', 'def', 'sp', '@det', '#1->4'], <br />
['"quick"', 'adj', 'sint', '@amod', '#2->4'], <br />
['"brown"', 'adj', '@amod', '#3->4'], <br />
['"fox"', 'n', 'sg', '@nsubj', '#4->5'], <br />
['"jump"', 'vblex', 'pres', 'p3', 'sg', '@root', '#5->0'], <br />
['"over"', 'pr', '@case', '#6->9'], <br />
['"the"', 'det', 'def', 'sp', '@det', '#7->9'], <br />
['"lazy"', 'adj', 'sint', '@amod', '#8->9'], <br />
['"dog"', 'n', 'sg', '@obl', '#9->5'], <br />
['"in"', 'pr', '@case', '#10->13'], <br />
['"the"', 'det', 'def', 'sp', '@det', '#11->13'], <br />
['"green"', 'adj', 'sint', '@amod', '#12->13'], <br />
['"field"', 'n', 'pl', '@obl', '#13->5'], <br />
['"."', 'sent']]<br />
</pre><br />
<br />
The next step that my program takes is using string formatting to extract the relevant aspects of this "info"--namely the "from word", the "to word", and the type of dependency (indicated by the '@' symbol). Once I have all of this information, I can simply plug it into the corresponding locations in the desired format. Therefore, the final Latex code outputted by the simplest version of my program is<br />
<br />
<pre><br />
\begin{dependency}<br />
\begin{deptext}[column sep=0.2cm]<br />
The \& quick \& brown \& fox \& jumps \& over \& the \& lazy \& dog \& in \& the \& green \& fields \& ROOT \\ <br />
\end{deptext}<br />
\depedge{4}{1}{det}<br />
\depedge{4}{2}{amod}<br />
\depedge{4}{3}{amod}<br />
\depedge{5}{4}{nsubj}<br />
\depedge{14}{5}{root}<br />
\depedge{9}{6}{case}<br />
\depedge{9}{7}{det}<br />
\depedge{9}{8}{amod}<br />
\depedge{5}{9}{obl}<br />
\depedge{13}{10}{case}<br />
\depedge{13}{11}{det}<br />
\depedge{13}{12}{amod}<br />
\depedge{5}{13}{obl}<br />
\end{dependency}<br />
</pre><br />
<br />
Once you add the line <code>\usepackage{tikz-dependency}</code> to a blank Latex file, you can add this code and get the resulting image:<br />
<br />
[[File:example graph basic.png|800px|Dependency tree of "The resulting graph after running the original CG dependency file through my program.]]<br />
<br />
== More Complicated Solution ==<br />
I also added several customizable features to the program. I will briefly explain how each works here.<br />
<br />
=== Visible POS Tags ===<br />
I added the capability to display the part of speech tags below the text of the sentence. However, since this option may not always be desired, one of the command line arguments for the program toggles it on or off. This is the same graph as above, except with the POS tags visible:<br />
<br />
[[File:example graph with pos.png|800px|Dependency tree of "The resulting graph after setting the POS tags as visible.]]<br />
<br />
=== Dependency Filter ===<br />
In some situations, it may be useful to only view dependencies of a certain type. My tool allows you to optionally specify specific tag names that you want to appear in the graph. If no individual dependency types are listed, it will default to showing all of them. This is the same sentence as the previous examples, but this time with only the 'amod' dependencies displayed:<br />
<br />
[[File:example graph with pos and filter.png|800px|Dependency tree of "The resulting graph after only displaying dependencies of type 'amod'.]]<br />
<br />
=== Batch Diagramming ===<br />
If this dependency visualization is done on a large scale, it would be tedious to run the program separately for each individual sentence in the corpus. To speed things up, I implemented an option to input a .txt file with a list of filenames. The autoglosser will take that list and generate a separate output file (containing Latex code) for each filename in the list. This makes large scale diagramming more efficient and only requires the user to construct one large file.<br />
<br />
== Hard-coded Parameters ==<br />
There were several design choices that I made because I thought they looked the best, but these can be changed with simple edits to the autoglosser.py file.<br />
<br />
=== Column/Row Spacing ===<br />
I added a default 0.2cm gap between columns (words) and a default 0.2ex gap between rows (only relevant when POS tags are visible).<br />
<br />
=== Word Spacing ===<br />
When there was a dependency between two consecutive words, the label was sometimes wider than the connecting arrow. To clean up the visual, I added an extra 0.5cm between columns whenever this occurred.<br />
<br />
=== Filename Format ===<br />
In my code, I hard-coded the program to take input files in the form "<label>_input.txt" and to create output files in the form "<label>_output.txt".<br />
<br />
== Evaluation ==<br />
it works, i promise<br />
<br />
<br />
[[Category:sp17_FinalProjects]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=File:Example_graph_with_pos_and_filter.png&diff=5301File:Example graph with pos and filter.png2017-05-10T06:08:43Z<p>Ltarlin1: </p>
<hr />
<div></div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=File:Example_graph_with_pos.png&diff=5300File:Example graph with pos.png2017-05-10T06:08:22Z<p>Ltarlin1: </p>
<hr />
<div></div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=File:Example_graph_basic.png&diff=5299File:Example graph basic.png2017-05-10T06:08:00Z<p>Ltarlin1: </p>
<hr />
<div></div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Ltarlin1/Final_Project&diff=5298Ltarlin1/Final Project2017-05-10T06:07:29Z<p>Ltarlin1: </p>
<hr />
<div>== Code ==<br />
[https://github.swarthmore.edu/ltarlin1/ling073-ltarlin1-autoglosser Github link]<br />
<br />
== The Problem ==<br />
For my final project, I decided to create an autoglosser that would automatically convert the universal dependency files we worked with in class into visual form in Latex. There is a Latex package called tikz-dependency that allows for quick input of sentences and its corresponding dependencies, but it still requires the user to manually select each dependency. Therefore, my code automatically generates Latex code that fits the expected format for the tikz-dependency package and therefore can easily be displayed in a graph, as in the following example image:<br />
<br />
[[File:Lee-tikz-dependency.png|800px|Dependency tree of "An example output of the tikz-dependency latex package.]]<br />
<br />
Although this graph is fancy and colorful, the output of my code is a simplified version that includes all of the most relevant information and has some customizable features. A description of the code, the output, and how to run the program follows.<br />
<br />
== Previous Work ==<br />
As discussed in the above section, the tikz-dependency package uses the tikz interface to facilitate the graph-making process. The syntax of a dependency in this format is strikingly similar to that which we saw in class (i.e. #4->6) because both refer to the "from word" and the "to word" using offset from the beginning of the sentence, so it was relatively simple to translate from one form to another.<br />
<br />
== Users ==<br />
This tool would be useful for linguists who want to speed up the visual-making process when working with universal dependencies. It does not have much of an application outside the technical linguistics domain because generating the input files to my program requires prior knowledge of universal dependencies.<br />
<br />
== Basic Solution ==<br />
My autoglosser parses each line of the CG file and separates it into the relevant portions--the words that make up the sentence, each corresponding part of speech, the other side of the dependency, and the type of dependence relationship. The more specific part-of-speech information present in the CG file is ignored because it would clutter the sentence diagram if it were included.<br />
<br />
Therefore, a CG file like the one we looked at in class<br />
<pre><br />
"<The>"<br />
"The" det def sp @det #1->4<br />
"<quick>"<br />
"quick" adj sint @amod #2->4<br />
"<brown>"<br />
"brown" adj @amod #3->4<br />
"<fox>"<br />
"fox" n sg @nsubj #4->5<br />
"<jumps>"<br />
"jump" vblex pres p3 sg @root #5->0<br />
"<over>"<br />
"over" pr @case #6->9<br />
"<the>"<br />
"the" det def sp @det #7->9<br />
"<lazy>"<br />
"lazy" adj sint @amod #8->9<br />
"<dog>"<br />
"dog" n sg @obl #9->5<br />
"<in>"<br />
"in" pr @case #10->13<br />
"<the>"<br />
"the" det def sp @det #11->13<br />
"<green>"<br />
"green" adj sint @amod #12->13<br />
"<fields>"<br />
"field" n pl @obl #13->5<br />
"<.>"<br />
"." sent<br />
</pre><br />
<br />
is turned into something like this:<br />
<pre><br />
words = ['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog', 'in', 'the', 'green', 'fields', '.']<br />
<br />
info = [<br />
['"The"', 'det', 'def', 'sp', '@det', '#1->4'], <br />
['"quick"', 'adj', 'sint', '@amod', '#2->4'], <br />
['"brown"', 'adj', '@amod', '#3->4'], <br />
['"fox"', 'n', 'sg', '@nsubj', '#4->5'], <br />
['"jump"', 'vblex', 'pres', 'p3', 'sg', '@root', '#5->0'], <br />
['"over"', 'pr', '@case', '#6->9'], <br />
['"the"', 'det', 'def', 'sp', '@det', '#7->9'], <br />
['"lazy"', 'adj', 'sint', '@amod', '#8->9'], <br />
['"dog"', 'n', 'sg', '@obl', '#9->5'], <br />
['"in"', 'pr', '@case', '#10->13'], <br />
['"the"', 'det', 'def', 'sp', '@det', '#11->13'], <br />
['"green"', 'adj', 'sint', '@amod', '#12->13'], <br />
['"field"', 'n', 'pl', '@obl', '#13->5'], <br />
['"."', 'sent']]<br />
</pre><br />
<br />
The next step that my program takes is using string formatting to extract the relevant aspects of this "info"--namely the "from word", the "to word", and the type of dependency (indicated by the '@' symbol). Once I have all of this information, I can simply plug it into the corresponding locations in the desired format. Therefore, the final Latex code outputted by the simplest version of my program is<br />
<br />
<pre><br />
\begin{dependency}<br />
\begin{deptext}[column sep=0.2cm]<br />
The \& quick \& brown \& fox \& jumps \& over \& the \& lazy \& dog \& in \& the \& green \& fields \& ROOT \\ <br />
\end{deptext}<br />
\depedge{4}{1}{det}<br />
\depedge{4}{2}{amod}<br />
\depedge{4}{3}{amod}<br />
\depedge{5}{4}{nsubj}<br />
\depedge{14}{5}{root}<br />
\depedge{9}{6}{case}<br />
\depedge{9}{7}{det}<br />
\depedge{9}{8}{amod}<br />
\depedge{5}{9}{obl}<br />
\depedge{13}{10}{case}<br />
\depedge{13}{11}{det}<br />
\depedge{13}{12}{amod}<br />
\depedge{5}{13}{obl}<br />
\end{dependency}<br />
</pre><br />
<br />
Once you add the line <code>\usepackage{tikz-dependency}</code> to a blank Latex file, you can add this code and get the resulting image:<br />
<br />
[[File:Lee-graph.png|800px|Dependency tree of "The resulting graph after running the original CG dependency file through my program.]]<br />
<br />
== More Complicated Solution ==<br />
I also added several customizable features to the program. I will briefly explain how each works here.<br />
<br />
=== Visible POS Tags ===<br />
I added the capability to display the part of speech tags below the text of the sentence. However, since this option may not always be desired, one of the command line arguments for the program toggles it on or off. This is the same graph as above, except with the POS tags visible:<br />
<br />
<br />
<br />
=== Dependency Filter ===<br />
<br />
<br />
=== Batch Diagramming ===<br />
<br />
<br />
== Hard-coded Parameters ==<br />
<br />
<br />
=== Column/Row Spacing ===<br />
<br />
<br />
=== Word Spacing ===<br />
<br />
== Evaluation ==<br />
it works, i promise<br />
<br />
<br />
[[Category:sp17_FinalProjects]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Ltarlin1/Final_Project&diff=5295Ltarlin1/Final Project2017-05-10T05:03:51Z<p>Ltarlin1: </p>
<hr />
<div>== Code ==<br />
[https://github.swarthmore.edu/ltarlin1/ling073-ltarlin1-autoglosser Github link]<br />
<br />
== The Problem ==<br />
For my final project, I decided to create an autoglosser that would automatically convert the universal dependency files we worked with in class into visual form in Latex. There is a Latex package called tikz-dependency that allows for quick input of sentences and its corresponding dependencies, but it still requires the user to manually select each dependency. Therefore, my code automatically generates Latex code that fits the expected format for the tikz-dependency package and therefore can easily be displayed in a graph, as in the following example image:<br />
<br />
[[File:Lee-tikz-dependency.png|800px|Dependency tree of "An example output of the tikz-dependency latex package.]]<br />
<br />
<br />
== Previous Work ==<br />
As discussed in the above section, the tikz-dependency package uses the tikz interface to facilitate the graph-making process. The syntax of a dependency in this format is strikingly similar to that which we saw in class (i.e. #4->6) because both refer to the "from word" and the "to word" using offset from the beginning of the sentence.<br />
<br />
Theoretically, I would be able to also convert input files in the conllu format (as well as the CG format we worked with in class) to appropriate Latex code, but I do not fully understand this format yet. I will continue to learn about the conllu format and hopefully have it up and running in a few days.<br />
<br />
== Users ==<br />
This tool would be useful for linguists who want to speed up the visual-making process when working with universal dependencies. It does not have much of an application outside the technical linguistics domain because generating the input files to my program requires knowledge of universal dependencies.<br />
<br />
== The Solution ==<br />
My autoglosser parses each line of the CG file and separates it into the relevant portions--the words that make up the sentence, the other word that it depends on, and the type of dependence relationship. The other information belonging to that word, such as part of speech, are included in the parse but ignored at this point.<br />
<br />
Therefore, a CG file like the one we looked at in class<br />
<pre><br />
"<The>"<br />
"The" det def sp @det #1->4<br />
"<quick>"<br />
"quick" adj sint @amod #2->4<br />
"<brown>"<br />
"brown" adj @amod #3->4<br />
"<fox>"<br />
"fox" n sg @nsubj #4->5<br />
"<jumps>"<br />
"jump" vblex pres p3 sg @root #5->0<br />
"<over>"<br />
"over" pr @case #6->9<br />
"<the>"<br />
"the" det def sp @det #7->9<br />
"<lazy>"<br />
"lazy" adj sint @amod #8->9<br />
"<dog>"<br />
"dog" n sg @obl #9->5<br />
"<in>"<br />
"in" pr @case #10->13<br />
"<the>"<br />
"the" det def sp @det #11->13<br />
"<green>"<br />
"green" adj sint @amod #12->13<br />
"<fields>"<br />
"field" n pl @obl #13->5<br />
"<.>"<br />
"." sent<br />
</pre><br />
<br />
is turned into something like this:<br />
<pre><br />
words = ['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog', 'in', 'the', 'green', 'fields', '.']<br />
<br />
info = [<br />
['"The"', 'det', 'def', 'sp', '@det', '#1->4'], <br />
['"quick"', 'adj', 'sint', '@amod', '#2->4'], <br />
['"brown"', 'adj', '@amod', '#3->4'], <br />
['"fox"', 'n', 'sg', '@nsubj', '#4->5'], <br />
['"jump"', 'vblex', 'pres', 'p3', 'sg', '@root', '#5->0'], <br />
['"over"', 'pr', '@case', '#6->9'], <br />
['"the"', 'det', 'def', 'sp', '@det', '#7->9'], <br />
['"lazy"', 'adj', 'sint', '@amod', '#8->9'], <br />
['"dog"', 'n', 'sg', '@obl', '#9->5'], <br />
['"in"', 'pr', '@case', '#10->13'], <br />
['"the"', 'det', 'def', 'sp', '@det', '#11->13'], <br />
['"green"', 'adj', 'sint', '@amod', '#12->13'], <br />
['"field"', 'n', 'pl', '@obl', '#13->5'], <br />
['"."', 'sent']]<br />
</pre><br />
<br />
The next step that my program takes is using string formatting to extract the relevant aspects of this "info"--namely the "from word", the "to word", and the type of dependency (indicated by the '@' symbol). Once I have all of this information, I can simply plug it into the corresponding locations in the desired format. Therefore, the final Latex code outputted by my program is<br />
<br />
<pre><br />
\begin{dependency}<br />
\begin{deptext}[column sep=0.2cm]<br />
The \& quick \& brown \& fox \& jumps \& over \& the \& lazy \& dog \& in \& the \& green \& fields \& ROOT \\ <br />
\end{deptext}<br />
\depedge{4}{1}{det}<br />
\depedge{4}{2}{amod}<br />
\depedge{4}{3}{amod}<br />
\depedge{5}{4}{nsubj}<br />
\depedge{14}{5}{root}<br />
\depedge{9}{6}{case}<br />
\depedge{9}{7}{det}<br />
\depedge{9}{8}{amod}<br />
\depedge{5}{9}{obl}<br />
\depedge{13}{10}{case}<br />
\depedge{13}{11}{det}<br />
\depedge{13}{12}{amod}<br />
\depedge{5}{13}{obl}<br />
\end{dependency}<br />
</pre><br />
<br />
Once you add the line <code>\usepackage{tikz-dependency}</code> to a blank Latex file, you can add this code and get the resulting image:<br />
<br />
[[File:Lee-graph.png|800px|Dependency tree of "The resulting graph after running the original CG dependency file through my program.]]<br />
<br />
<br />
== Evaluation ==<br />
it works, i promise<br />
<br />
<br />
[[Category:sp17_FinalProjects]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Ltarlin1/Final_Project&diff=5078Ltarlin1/Final Project2017-05-05T07:03:53Z<p>Ltarlin1: </p>
<hr />
<div>== The Problem ==<br />
For my final project, I decided to create an autoglosser that would automatically convert the universal dependency files we worked with in class into visual form in Latex. There is a Latex package called tikz-dependency that allows for quick input of sentences and its corresponding dependencies, but it still requires the user to manually select each dependency. Therefore, my code automatically generates Latex code that fits the expected format for the tikz-dependency package and therefore can easily be displayed in a graph, as in the following example image:<br />
<br />
[[File:Lee-tikz-dependency.png|800px|Dependency tree of "An example output of the tikz-dependency latex package.]]<br />
<br />
<br />
== Previous Work ==<br />
As discussed in the above section, the tikz-dependency package uses the tikz interface to facilitate the graph-making process. The syntax of a dependency in this format is strikingly similar to that which we saw in class (i.e. #4->6) because both refer to the "from word" and the "to word" using offset from the beginning of the sentence.<br />
<br />
Theoretically, I would be able to also convert input files in the conllu format (as well as the CG format we worked with in class) to appropriate Latex code, but I do not fully understand this format yet. I will continue to learn about the conllu format and hopefully have it up and running in a few days.<br />
<br />
== Users ==<br />
This tool would be useful for linguists who want to speed up the visual-making process when working with universal dependencies. It does not have much of an application outside the technical linguistics domain because generating the input files to my program requires knowledge of universal dependencies.<br />
<br />
== The Solution ==<br />
My autoglosser parses each line of the CG file and separates it into the relevant portions--the words that make up the sentence, the other word that it depends on, and the type of dependence relationship. The other information belonging to that word, such as part of speech, are included in the parse but ignored at this point.<br />
<br />
Therefore, a CG file like the one we looked at in class<br />
<pre><br />
"<The>"<br />
"The" det def sp @det #1->4<br />
"<quick>"<br />
"quick" adj sint @amod #2->4<br />
"<brown>"<br />
"brown" adj @amod #3->4<br />
"<fox>"<br />
"fox" n sg @nsubj #4->5<br />
"<jumps>"<br />
"jump" vblex pres p3 sg @root #5->0<br />
"<over>"<br />
"over" pr @case #6->9<br />
"<the>"<br />
"the" det def sp @det #7->9<br />
"<lazy>"<br />
"lazy" adj sint @amod #8->9<br />
"<dog>"<br />
"dog" n sg @obl #9->5<br />
"<in>"<br />
"in" pr @case #10->13<br />
"<the>"<br />
"the" det def sp @det #11->13<br />
"<green>"<br />
"green" adj sint @amod #12->13<br />
"<fields>"<br />
"field" n pl @obl #13->5<br />
"<.>"<br />
"." sent<br />
</pre><br />
<br />
is turned into something like this:<br />
<pre><br />
words = ['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog', 'in', 'the', 'green', 'fields', '.']<br />
<br />
info = [<br />
['"The"', 'det', 'def', 'sp', '@det', '#1->4'], <br />
['"quick"', 'adj', 'sint', '@amod', '#2->4'], <br />
['"brown"', 'adj', '@amod', '#3->4'], <br />
['"fox"', 'n', 'sg', '@nsubj', '#4->5'], <br />
['"jump"', 'vblex', 'pres', 'p3', 'sg', '@root', '#5->0'], <br />
['"over"', 'pr', '@case', '#6->9'], <br />
['"the"', 'det', 'def', 'sp', '@det', '#7->9'], <br />
['"lazy"', 'adj', 'sint', '@amod', '#8->9'], <br />
['"dog"', 'n', 'sg', '@obl', '#9->5'], <br />
['"in"', 'pr', '@case', '#10->13'], <br />
['"the"', 'det', 'def', 'sp', '@det', '#11->13'], <br />
['"green"', 'adj', 'sint', '@amod', '#12->13'], <br />
['"field"', 'n', 'pl', '@obl', '#13->5'], <br />
['"."', 'sent']]<br />
</pre><br />
<br />
The next step that my program takes is using string formatting to extract the relevant aspects of this "info"--namely the "from word", the "to word", and the type of dependency (indicated by the '@' symbol). Once I have all of this information, I can simply plug it into the corresponding locations in the desired format. Therefore, the final Latex code outputted by my program is<br />
<br />
<pre><br />
\begin{dependency}<br />
\begin{deptext}[column sep=0.2cm]<br />
The \& quick \& brown \& fox \& jumps \& over \& the \& lazy \& dog \& in \& the \& green \& fields \& ROOT \\ <br />
\end{deptext}<br />
\depedge{4}{1}{det}<br />
\depedge{4}{2}{amod}<br />
\depedge{4}{3}{amod}<br />
\depedge{5}{4}{nsubj}<br />
\depedge{14}{5}{root}<br />
\depedge{9}{6}{case}<br />
\depedge{9}{7}{det}<br />
\depedge{9}{8}{amod}<br />
\depedge{5}{9}{obl}<br />
\depedge{13}{10}{case}<br />
\depedge{13}{11}{det}<br />
\depedge{13}{12}{amod}<br />
\depedge{5}{13}{obl}<br />
\end{dependency}<br />
</pre><br />
<br />
Once you add the line <code>\usepackage{tikz-dependency}</code> to a blank Latex file, you can add this code and get the resulting image:<br />
<br />
[[File:Lee-graph.png|800px|Dependency tree of "The resulting graph after running the original CG dependency file through my program.]]<br />
<br />
<br />
== Evaluation ==<br />
it works, i promise<br />
<br />
<br />
[[Category:sp17_FinalProjects]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=File:Lee-graph.png&diff=5077File:Lee-graph.png2017-05-05T07:02:09Z<p>Ltarlin1: </p>
<hr />
<div></div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Ltarlin1/Final_Project&diff=5076Ltarlin1/Final Project2017-05-05T07:01:59Z<p>Ltarlin1: </p>
<hr />
<div>== The Problem ==<br />
For my final project, I decided to create an autoglosser that would automatically convert the universal dependency files we worked with in class into visual form in Latex. There is a Latex package called tikz-dependency that allows for quick input of sentences and its corresponding dependencies, but it still requires the user to manually select each dependency. Therefore, my code automatically generates Latex code that fits the expected format for the tikz-dependency package and therefore can easily be displayed in a graph, as in the following example image:<br />
<br />
[[File:Lee-tikz-dependency.png|800px|Dependency tree of "An example output of the tikz-dependency latex package.]]<br />
<br />
<br />
== Previous Work ==<br />
As discussed in the above section, the tikz-dependency package uses the tikz interface to facilitate the graph-making process. The syntax of a dependency in this format is strikingly similar to that which we saw in class (i.e. #4->6) because both refer to the "from word" and the "to word" using offset from the beginning of the sentence.<br />
<br />
Theoretically, I would be able to also convert input files in the conllu format (as well as the CG format we worked with in class) to appropriate Latex code, but I do not fully understand this format yet. I will continue to learn about the conllu format and hopefully have it up and running in a few days.<br />
<br />
== Users ==<br />
This tool would be useful for linguists who want to speed up the visual-making process when working with universal dependencies. It does not have much of an application outside the technical linguistics domain because generating the input files to my program requires knowledge of universal dependencies.<br />
<br />
== The Solution ==<br />
My autoglosser parses each line of the CG file and separates it into the relevant portions--the words that make up the sentence, the other word that it depends on, and the type of dependence relationship. The other information belonging to that word, such as part of speech, are included in the parse but ignored at this point.<br />
<br />
Therefore, a CG file like the one we looked at in class<br />
<pre><br />
"<The>"<br />
"The" det def sp @det #1->4<br />
"<quick>"<br />
"quick" adj sint @amod #2->4<br />
"<brown>"<br />
"brown" adj @amod #3->4<br />
"<fox>"<br />
"fox" n sg @nsubj #4->5<br />
"<jumps>"<br />
"jump" vblex pres p3 sg @root #5->0<br />
"<over>"<br />
"over" pr @case #6->9<br />
"<the>"<br />
"the" det def sp @det #7->9<br />
"<lazy>"<br />
"lazy" adj sint @amod #8->9<br />
"<dog>"<br />
"dog" n sg @obl #9->5<br />
"<in>"<br />
"in" pr @case #10->13<br />
"<the>"<br />
"the" det def sp @det #11->13<br />
"<green>"<br />
"green" adj sint @amod #12->13<br />
"<fields>"<br />
"field" n pl @obl #13->5<br />
"<.>"<br />
"." sent<br />
</pre><br />
<br />
is turned into something like this:<br />
<pre><br />
words = ['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog', 'in', 'the', 'green', 'fields', '.']<br />
<br />
info = [<br />
['"The"', 'det', 'def', 'sp', '@det', '#1->4'], <br />
['"quick"', 'adj', 'sint', '@amod', '#2->4'], <br />
['"brown"', 'adj', '@amod', '#3->4'], <br />
['"fox"', 'n', 'sg', '@nsubj', '#4->5'], <br />
['"jump"', 'vblex', 'pres', 'p3', 'sg', '@root', '#5->0'], <br />
['"over"', 'pr', '@case', '#6->9'], <br />
['"the"', 'det', 'def', 'sp', '@det', '#7->9'], <br />
['"lazy"', 'adj', 'sint', '@amod', '#8->9'], <br />
['"dog"', 'n', 'sg', '@obl', '#9->5'], <br />
['"in"', 'pr', '@case', '#10->13'], <br />
['"the"', 'det', 'def', 'sp', '@det', '#11->13'], <br />
['"green"', 'adj', 'sint', '@amod', '#12->13'], <br />
['"field"', 'n', 'pl', '@obl', '#13->5'], <br />
['"."', 'sent']]<br />
</pre><br />
<br />
The next step that my program takes is using string formatting to extract the relevant aspects of this "info"--namely the "from word", the "to word", and the type of dependency (indicated by the '@' symbol). Once I have all of this information, I can simply plug it into the corresponding locations in the desired format. Therefore, the final Latex code outputted by my program is<br />
<br />
<pre><br />
\begin{dependency}<br />
\begin{deptext}[column sep=0.2cm]<br />
The \& quick \& brown \& fox \& jumps \& over \& the \& lazy \& dog \& in \& the \& green \& fields \& ROOT \\ <br />
\end{deptext}<br />
\depedge{4}{1}{det}<br />
\depedge{4}{2}{amod}<br />
\depedge{4}{3}{amod}<br />
\depedge{5}{4}{nsubj}<br />
\depedge{14}{5}{root}<br />
\depedge{9}{6}{case}<br />
\depedge{9}{7}{det}<br />
\depedge{9}{8}{amod}<br />
\depedge{5}{9}{obl}<br />
\depedge{13}{10}{case}<br />
\depedge{13}{11}{det}<br />
\depedge{13}{12}{amod}<br />
\depedge{5}{13}{obl}<br />
\end{dependency}<br />
</pre><br />
<br />
Once you add the line <code>\usepackage{tikz-dependency}</code> to a blank Latex file, you can add this code and get the resulting image:<br />
<br />
asdf<br />
<br />
== Evaluation ==<br />
it works, i promise<br />
<br />
<br />
<br />
<br />
[[Category:sp17_FinalProjects]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=File:Lee-tikz-dependency.png&diff=5075File:Lee-tikz-dependency.png2017-05-05T06:51:59Z<p>Ltarlin1: </p>
<hr />
<div></div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Ltarlin1/Final_Project&diff=5074Ltarlin1/Final Project2017-05-05T06:51:41Z<p>Ltarlin1: </p>
<hr />
<div>== The Problem ==<br />
For my final project, I decided to create an autoglosser that would automatically convert the universal dependency files we worked with in class into visual form in Latex. There is a Latex package called tikz-dependency that allows for quick input of sentences and its corresponding dependencies, but it still requires the user to manually select each dependency. Therefore, my code automatically generates Latex code that fits the expected format for the tikz-dependency package and therefore can easily be displayed in a graph, as in the following example image:<br />
<br />
[[File:UD tree example.png|800px|Dependency tree of "Everyone in this class works on a different language.]]<br />
<br />
<br />
== Previous Work ==<br />
As discussed in the above section, the tikz-dependency package uses the tikz interface to facilitate the graph-making process. The syntax of a dependency in this format is strikingly similar to that which we saw in class (i.e. #4->6) because both refer to the "from word" and the "to word" using offset from the beginning of the sentence.<br />
<br />
Theoretically, I would be able to also convert input files in the conllu format (as well as the CG format we worked with in class) to appropriate Latex code, but I do not fully understand this format yet. I will continue to learn about the conllu format and hopefully have it up and running in a few days.<br />
<br />
== Users ==<br />
This tool would be useful for linguists who want to speed up the visual-making process when working with universal dependencies. It does not have much of an application outside the technical linguistics domain because generating the input files to my program requires knowledge of universal dependencies.<br />
<br />
== The Solution ==<br />
My autoglosser parses each line of the CG file and separates it into the relevant portions--the words that make up the sentence, the other word that it depends on, and the type of dependence relationship. The other information belonging to that word, such as part of speech, are included in the parse but ignored at this point.<br />
<br />
Therefore, a CG file like the one we looked at in class<br />
<pre><br />
"<The>"<br />
"The" det def sp @det #1->4<br />
"<quick>"<br />
"quick" adj sint @amod #2->4<br />
"<brown>"<br />
"brown" adj @amod #3->4<br />
"<fox>"<br />
"fox" n sg @nsubj #4->5<br />
"<jumps>"<br />
"jump" vblex pres p3 sg @root #5->0<br />
"<over>"<br />
"over" pr @case #6->9<br />
"<the>"<br />
"the" det def sp @det #7->9<br />
"<lazy>"<br />
"lazy" adj sint @amod #8->9<br />
"<dog>"<br />
"dog" n sg @obl #9->5<br />
"<in>"<br />
"in" pr @case #10->13<br />
"<the>"<br />
"the" det def sp @det #11->13<br />
"<green>"<br />
"green" adj sint @amod #12->13<br />
"<fields>"<br />
"field" n pl @obl #13->5<br />
"<.>"<br />
"." sent<br />
</pre><br />
<br />
is turned into something like this:<br />
<pre><br />
words = ['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog', 'in', 'the', 'green', 'fields', '.']<br />
<br />
info = [<br />
['"The"', 'det', 'def', 'sp', '@det', '#1->4'], <br />
['"quick"', 'adj', 'sint', '@amod', '#2->4'], <br />
['"brown"', 'adj', '@amod', '#3->4'], <br />
['"fox"', 'n', 'sg', '@nsubj', '#4->5'], <br />
['"jump"', 'vblex', 'pres', 'p3', 'sg', '@root', '#5->0'], <br />
['"over"', 'pr', '@case', '#6->9'], <br />
['"the"', 'det', 'def', 'sp', '@det', '#7->9'], <br />
['"lazy"', 'adj', 'sint', '@amod', '#8->9'], <br />
['"dog"', 'n', 'sg', '@obl', '#9->5'], <br />
['"in"', 'pr', '@case', '#10->13'], <br />
['"the"', 'det', 'def', 'sp', '@det', '#11->13'], <br />
['"green"', 'adj', 'sint', '@amod', '#12->13'], <br />
['"field"', 'n', 'pl', '@obl', '#13->5'], <br />
['"."', 'sent']]<br />
</pre><br />
<br />
more stuff here<br />
<br />
== Evaluation ==<br />
it works, i promise<br />
<br />
<br />
<br />
<br />
[[Category:sp17_FinalProjects]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Ltarlin1/Final_Project&diff=5073Ltarlin1/Final Project2017-05-05T06:16:03Z<p>Ltarlin1: </p>
<hr />
<div>== The Problem ==<br />
For my final project, I decided to create an autoglosser that would automatically convert the universal dependency files we worked with in class into visual form in Latex. There is a Latex package called tikz-dependency that allows for quick input of sentences and its corresponding dependencies, but it still requires the user to manually select each dependency. Therefore, my code automatically generates Latex code that fits the expected format for the tikz-dependency package and therefore can easily be displayed in a graph.<br />
<br />
== Previous Work ==<br />
As discussed in the above section, the tikz-dependency package uses the tikz interface to facilitate the graph-making process. The syntax of a dependency in this format is strikingly similar to that which we saw in class (i.e. #4->6) because both refer to the "from word" and the "to word" using offset from the beginning of the sentence.<br />
<br />
Theoretically, I would be able to also convert input files in the conllu format (as well as the CG format we worked with in class) to appropriate Latex code, but I do not fully understand this format yet. I will continue to learn about the conllu format and hopefully have it up and running in a few days.<br />
<br />
<br />
<br />
[[Category:sp17_FinalProjects]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Ltarlin1/Final_Project&diff=5072Ltarlin1/Final Project2017-05-05T06:14:13Z<p>Ltarlin1: </p>
<hr />
<div>I'm gonna make this later but in case anyone clicks on this page hoping to know what I'm doing, I'm making an autoglosser that converts a dependency file (in CG form) to Latex code to interact with the tikz-dependency visualization package<br />
<br />
== The Problem ==<br />
For my final project, I decided to create an autoglosser that would automatically convert the universal dependency files we worked with in class into visual form in Latex. There is a Latex package called tikz-dependency that allows for quick input of sentences and its corresponding dependencies, but it still requires the user to manually select each dependency. Therefore, my code automatically generates Latex code that fits the expected format for the tikz-dependency package and therefore can easily be displayed in a graph.<br />
<br />
== Previous Work ==<br />
As discussed in the above section, the tikz-dependency package uses the tikz interface to facilitate the graph-making process. The syntax of a dependency in this format is strikingly similar to that which we saw in class (i.e. #4->6) because both refer to the "from word" and the "to word" using offset from the beginning of the sentence.<br />
<br />
Theoretically, I would be able to also convert input files in the conllu format (as well as the CG format we worked with in class) to appropriate Latex code, but I do not fully understand this format yet. I will continue to learn about the conllu format and hopefully have it up and running in a few days.<br />
<br />
<br />
[[Category:sp17_FinalProjects]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Ltarlin1/Final_Project&diff=5067Ltarlin1/Final Project2017-05-05T05:45:14Z<p>Ltarlin1: </p>
<hr />
<div>I'm gonna make this later but in case anyone clicks on this page hoping to know what I'm doing, I'm making an autoglosser that converts a dependency file (in CG form) to Latex code to interact with the tikz-dependency visualization package<br />
<br />
[[Category:sp17_FinalProjects]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Ltarlin1/Final_Project&diff=5065Ltarlin1/Final Project2017-05-05T05:44:49Z<p>Ltarlin1: </p>
<hr />
<div>I'm gonna make this later but in case anyone clicks on this page, I'm making an autoglosser that converts a dependency file (in CG form) to Latex code to interact with the tikz-dependency visualization package<br />
<br />
[[Category:sp17_FinalProjects]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Ltarlin1/Final_Project&diff=5063Ltarlin1/Final Project2017-05-05T05:43:13Z<p>Ltarlin1: </p>
<hr />
<div>I'm gonna make this later<br />
<br />
[[Category:sp17_FinalProjects]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Ltarlin1/Final_Project&diff=5062Ltarlin1/Final Project2017-05-05T05:42:52Z<p>Ltarlin1: Created page with "I'm gonna make this later"</p>
<hr />
<div>I'm gonna make this later</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Bikol_and_Chamorro/Structural_transfer&diff=4873Bikol and Chamorro/Structural transfer2017-04-25T04:33:38Z<p>Ltarlin1: </p>
<hr />
<div>== Bikol to Chamorro ==<br />
<br />
=== Modifiers ===<br />
The item I chose to deal with is the presence of a modifier describing a noun. Chamorro places the modifier before the noun while Bikol places the noun first. Furthermore, the subject pronoun is placed at the end in Chamorro but before the noun-modifier phrase in Bikol.<br />
* Example sentence: I went to the big house.<br />
** Chamorro: Malak i dánkolo na gumaʼ yoʼ<br />
** Bikol: Nagdumán akó sa haróng na dakúla<br />
<br />
Here are the outputs for the following modes after structural transfer.<br />
* <b>tagger:</b> ^dumán<vblex><past>$ ^akó<prn><p1><sg>$ ^sa<det><def>$ ^haróng<n>$ ^na<link>$ ^dakúla<adj><sg>$^.<sent>$<br />
* <b>biltrans:</b> ^dumán<vblex><past>/malak<vblex><past>$ ^akó<prn><p1><sg>/yoʼ<prn><p1><sg>$ ^sa<det><def>/i<det><def>$ ^haróng<n>/gumaʼ<n>$ ^na<link>/na<link>$ ^dakúla<adj><sg>/dánkolo<adj><sg>$^.<sent>/.<sent>$<br />
* <b>chunker:</b> apertium-transfer: Rule 2 akó<prn><p1><sg>/yoʼ<prn><p1><sg> sa<det><def>/i<det><def> haróng<n>/gumaʼ<n> na<link>/na<link> dakúla<adj><sg>/dánkolo<adj><sg><br />
<br />
apertium-transfer: Rule 1 .<sent>/.<sent><br />
^default<default>{^malak<vblex><past>$}$ ^a_type<DET>{^i<det>$}$ ^a_type<SA>{^dánkolo<adj>$}$ ^a_type<LINK>{^na<link>$}$ ^a_type<SN>{^gumaʼ<n>$}$ ^a_type<PRN>{^yoʼ$}$^sent<SENT>{^.<sent>$}$<br />
* <b>interchunk:</b> apertium-interchunk: Rule 1 a_type<SN>{^gumaʼ<n>$}<br />
^default<default>{^malak<vblex><past>$}$ ^a_type<DET>{^i<det>$}$ ^a_type<SA>{^dánkolo<adj>$}$ ^a_type<LINK>{^na<link>$}$ ^a_type<SN>{^gumaʼ<n>$}$ ^a_type<PRN>{^yoʼ$}$^sent<SENT>{^.<sent>$}$<br />
* <b>postchunk:</b> ^malak<vblex><past>$ ^i<det>$ ^dánkolo<adj>$ ^na<link>$ ^gumaʼ<n>$ ^yoʼ$^.<sent>$<br />
* <b>bcl-cha</b> #malak i dánkolo na #gumaʼ #yoʼ<br />
<br />
=== Pre-evaluation ===<br />
* WER = 94.90%<br />
* PER = 91.72%<br />
* Percentage of unknown words = 87.41%<br />
<br />
=== Post-evaluation ===<br />
* WER = 94.90%<br />
* PER = 90.45%<br />
* Percentage of unknown words = 87.41%<br />
<br />
== Chamorro to Bikol ==<br />
<br />
=== Pluralizing Nouns ===<br />
The item I chose to deal with in structural transfer is plural nouns. In Chamorro, a prefix is added to a noun to make it plural, while in Bikol, a separate lemma is added before the noun to pluralize it.<br />
* Example sentence: You are teachers.<br />
** Chamorro: Manmaʼestro hamyo <br />
** Bikol: Mga maéstro kamó<br />
<br />
Here are the outputs for the following modes after structural transfer was implemented for plural nouns.<br />
* <b>tagger:</b> ^Maʼestro<n><pl>$ ^hamyo<prn><px2pl>$^.<sent>$<br />
* <b>biltrans:</b> ^Maʼestro<n><pl>/Maéstro<n>$ ^hamyo<prn><px2pl>/kamó<prn>$^.<sent>/.<sent>$<br />
* <b>chunker:</b><br />
apertium-transfer: Rule 2 Maʼestro<n><pl>/Maéstro<n><br />
<br />
apertium-transfer: Rule 1 .<sent>/.<sent><br />
^nm<pl>{^mga<pl>$}$ ^n<Noun>{^Maéstro<n>$}$ ^default<default>{^kamó<prn>$}$^sent<SENT>{^.<sent>$}$<br />
* <b>interchunk:</b> ^nm<pl>{^mga<pl>$}$ ^n<Noun>{^Maéstro<n>$}$ ^default<default>{^kamó<prn>$}$^sent<SENT>{^.<sent>$}$<br />
* <b>postchunk:</b> ^mga<pl>$ ^Maéstro<n>$ ^kamó<prn>$^.<sent>$<br />
* <b>cha-bcl:</b> mga Maéstro #kamó<br />
tagger, biltrans, chunker, interchunk, postchunk, and the pair itself (abc-xyz)<br />
<br />
=== Pre-evaluation ===<br />
* WER = 96.32%<br />
* PER = 89.57%<br />
* Percentage of unknown words = 91.72%<br />
<br />
=== Post-evaluation ===<br />
* WER = 89.47%<br />
* PER = 89.47%<br />
* Percentage of unknown words = 10.00%<br />
<br />
[[Category:Sp17_StructuralTransfer]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Bikol_and_Chamorro/Structural_transfer&diff=4656Bikol and Chamorro/Structural transfer2017-04-19T19:46:29Z<p>Ltarlin1: </p>
<hr />
<div>== Bikol to Chamorro ==<br />
<br />
=== Pre-evaluation ===<br />
* WER = 94.90%<br />
* PER = 91.72%<br />
* Percentage of unknown words = 87.41%<br />
<br />
== Chamorro to Bikol ==<br />
<br />
=== Pluralizing Nouns ===<br />
The item I chose to deal with in structural transfer is plural nouns. In Chamorro, a prefix is added to a noun to make it plural, while in Bikol, a separate lemma is added before the noun to pluralize it.<br />
* Example sentence: You are teachers.<br />
** Chamorro: Manmaʼestro hamyo <br />
** Bikol: Mga maéstro kamó<br />
<br />
Here are the outputs for the following modes after structural transfer was implemented for plural nouns.<br />
* <b>tagger:</b> ^Maʼestro<n><pl>$ ^hamyo<prn><px2pl>$^.<sent>$<br />
* <b>biltrans:</b> ^Maʼestro<n><pl>/Maéstro<n>$ ^hamyo<prn><px2pl>/kamó<prn>$^.<sent>/.<sent>$<br />
* <b>chunker:</b><br />
apertium-transfer: Rule 2 Maʼestro<n><pl>/Maéstro<n><br />
<br />
apertium-transfer: Rule 1 .<sent>/.<sent><br />
^nm<pl>{^mga<pl>$}$ ^n<Noun>{^Maéstro<n>$}$ ^default<default>{^kamó<prn>$}$^sent<SENT>{^.<sent>$}$<br />
* <b>interchunk:</b> ^nm<pl>{^mga<pl>$}$ ^n<Noun>{^Maéstro<n>$}$ ^default<default>{^kamó<prn>$}$^sent<SENT>{^.<sent>$}$<br />
* <b>postchunk:</b> ^mga<pl>$ ^Maéstro<n>$ ^kamó<prn>$^.<sent>$<br />
* <b>cha-bcl:</b> mga Maéstro #kamó<br />
tagger, biltrans, chunker, interchunk, postchunk, and the pair itself (abc-xyz)<br />
<br />
=== Pre-evaluation ===<br />
* WER = 96.32%<br />
* PER = 89.57%<br />
* Percentage of unknown words = 91.72%<br />
<br />
=== Post-evaluation ===<br />
* WER = 89.47%<br />
* PER = 89.47%<br />
* Percentage of unknown words = 10.00%<br />
<br />
[[Category:Sp17_StructuralTransfer]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Bikol_and_Chamorro/Lexical_Selection&diff=4615Bikol and Chamorro/Lexical Selection2017-04-18T15:27:05Z<p>Ltarlin1: </p>
<hr />
<div>== bcl → cha Evaluation ==<br />
<br />
==== bóla ====<br />
In Bikol, <b>bóla</b> means ball or compliment. In Chamorro, ball = <i>bola</i> and compliment = <i>komplimenta</i>.<br />
<br />
Lexical selection between bola and komplimenta is guided by the following rules:<br />
* <i>Bola</i> (ball) is chosen when:<br />
** Preceded by a verb such as throw, toss, catch, play, buy, borrow, lend, bounce<br />
** Followed by an adjective such as round, colors<br />
* <i>Komplimenta</i> (compliment) is chosen as a default if the above conditions are not satisfied.<br />
<br />
Example sentences<br />
* Bola (ball) is chosen in the following example:<br />
** Sublion mo si bola ki Jose (<u>Borrow</u> the <i>ball</i> from Jacob)<br />
* Komplimenta (compliment) is chosen in the following example:<br />
** Itaó mo an bola (Give a <i>compliment</i>)<br />
<br />
==== glóbo ====<br />
In Bikol, <b>glóbo</b> means map or balloon. In Chamorro, map = <i>mapa</i> and balloon = <i>abubu</i>.<br />
<br />
For now, the default selection is set to translate glóbo to abubu, or balloon in English.<br />
<br />
== cha → bcl Evalutaion ==<br />
<br />
==== guakse ====<br />
In Chamorro, <b>guakse</b> means to scrub (clothes) or to turn inside out. In Bikol, to scrub (clothes) = <i>kuró-kusó</i> and to turn inside out = <i>balík</i>.<br />
<br />
Lexical selection between kuró-kusó and balík is guided by the following rules:<br />
* kuró-kusó (scrub clothes) is chosen when:<br />
** Followed by a definite article and then a word meaning "clothes"<br />
<br />
Example sentences<br />
* kuró-kusó is chosen in the following example:<br />
** Hu guakse i magagu-hu (I <i>scrubbed</i> my <u>clothes</u>)<br />
* balík is chosen in the following example:<br />
** Hu guakse i guma'-hu (I <i>scrubbed</i> my <u>house</u>)<br />
<br />
==== maggem ====<br />
In Chamorro, <b>maggem</b> means cautious or damp. In Bikol, cautious = <i>máan</i> and damp = <i>basá</i>.<br />
<br />
For now, the default selection is set to translate maggem to basá, or damp in English.<br />
<br />
[[Category:Sp17_LexicalSelection]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Bikol_and_Chamorro/Structural_transfer&diff=4468Bikol and Chamorro/Structural transfer2017-04-11T15:58:35Z<p>Ltarlin1: /* Chamorro to Bikol */</p>
<hr />
<div>== Pre-evaluation ==<br />
=== Chamorro to Bikol ===<br />
* WER = 96.32% <------this might be bad<br />
* PER = 89.57% <------this also might be bad<br />
* Percentage of unknown words = 91.72% <-----this is definitely bad<br />
<br />
<br />
[[Category:Sp17_StructuralTransfer]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Bikol_and_Chamorro/Structural_transfer&diff=4466Bikol and Chamorro/Structural transfer2017-04-11T15:57:21Z<p>Ltarlin1: </p>
<hr />
<div>== Pre-evaluation ==<br />
=== Chamorro to Bikol ===<br />
* WER = 96.32%<br />
* PER = 89.57%<br />
* Percentage of unknown words = 91.72% <-----this is bad<br />
<br />
<br />
[[Category:Sp17_StructuralTransfer]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Bikol_and_Chamorro/Lexical_Selection&diff=4289Bikol and Chamorro/Lexical Selection2017-04-04T16:37:17Z<p>Ltarlin1: </p>
<hr />
<div>== bcl → cha Evaluation ==<br />
<br />
==== bóla ====<br />
In Bikol, <b>bóla</b> means ball or compliment. In Chamorro, ball = <i>bola</i> and compliment = <i>komplimenta</i>.<br />
<br />
Lexical selection between bola and komplimenta is guided by the following rules:<br />
* Bola (ball) is chosen when:<br />
** Preceded by a verb such as throw, toss, catch, play, buy, borrow, lend, bounce<br />
** Followed by an adjective such as round, colors<br />
<br />
Example sentences<br />
* Bola (ball) is chosen in the following example:<br />
** Sublion mo si bola ki Jose (<u>Borrow</u> the <i>ball</i> from Jacob)<br />
* Komplimenta (compliment) is chosen in the following example:<br />
** <example here><br />
<br />
==== glóbo ====<br />
In Bikol, <b>glóbo</b> means map or balloon. In Chamorro, map = <i>mapa</i> and balloon = <i>abubu</i>.<br />
<br />
For now, the default selection is set to translate glóbo to abubu, or balloon in English.<br />
<br />
== cha → bcl Evalutaion ==<br />
<br />
==== guakse ====<br />
In Chamorro, <b>guakse</b> means to scrub (clothes) or to turn inside out. In Bikol, to scrub (clothes) = <i>kuró-kusó</i> and to turn inside out = <i>balík</i>.<br />
<br />
Lexical selection between kuró-kusó and balík is guided by the following rules:<br />
* kuró-kusó (scrub clothes) is chosen when:<br />
** Followed by a definite article and then a word meaning "clothes"<br />
<br />
Example sentences<br />
* kuró-kusó is chosen in the following example:<br />
** Hu guakse i magagu-hu (I <i>scrubbed</i> my <u>clothes</u>)<br />
* balík is chosen in the following example:<br />
** <example here><br />
<br />
==== maggem ====<br />
In Chamorro, <b>maggem</b> means cautious or damp. In Bikol, cautious = <i>máan</i> and damp = <i>basá</i>.<br />
<br />
Lexical selection between máan and basá is guided by the following rules:<br />
* basá (damp) is chosen when:<br />
** <rule here><br />
<br />
Example sentences<br />
* basá is chosen in the following example:<br />
** <example here><br />
* máan is chosen in the following example:<br />
** <example here><br />
<br />
<br />
[[Category:Sp17_LexicalSelection]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Bikol_and_Chamorro/Lexical_Selection&diff=4273Bikol and Chamorro/Lexical Selection2017-04-04T16:27:16Z<p>Ltarlin1: /* cha → bcl Evalutaion */</p>
<hr />
<div>== bcl → cha Evaluation ==<br />
<br />
==== bóla ====<br />
In Bikol, <b>bóla</b> means ball or compliment. In Chamorro, ball = <i>bola</i> and compliment = <i>komplimenta</i>.<br />
<br />
Lexical selection between bola and komplimenta is guided by the following rules:<br />
* Bola (ball) is chosen when:<br />
** Preceded by a verb such as throw, toss, catch, play, buy, borrow, lend, bounce<br />
** Followed by an adjective such as round, colors<br />
<br />
Example sentences<br />
* Bola (ball) is chosen in the following example:<br />
** Sublion mo si bola ki Jose (<u>Borrow</u> the <i>ball</i> from Jacob)<br />
* Komplimenta (compliment) is chosen in the following example:<br />
** <example here><br />
<br />
==== glóbo ====<br />
In Bikol, <b>glóbo</b> means map or balloon. In Chamorro, map = <i>mapa</i> and balloon = <i>abubu</i>.<br />
<br />
For now, the default selection is set to translate glóbo to abubu, or balloon in English.<br />
== cha → bcl Evalutaion ==<br />
In Chamorro, <b>guakse</b> means to scrub (clothes) or to turn inside out. In Bikol, to scrub (clothes) = <i>kuró-kusó</i> and to turn inside out = <i>balík</i>.<br />
<br />
Lexical selection between kuró-kusó and balík is guided by the following rules:<br />
* kuró-kusó (scrub clothes) is chosen when:<br />
** Followed by a definite article and then a word meaning "clothes"<br />
<br />
Example sentences<br />
* kuró-kusó is chosen in the following example:<br />
** Hu guakse i magagu-hu (I <i>scrubbed</i> my <u>clothes</u>)<br />
* balík is chosen in the following example:<br />
** <example here><br />
<br />
In Chamorro, <b>maggem</b> means cautious or damp. In Bikol, cautious = <i>máan</i> and damp = <i>basá</i>.<br />
<br />
Lexical selection between máan and basá is guided by the following rules:<br />
* basá (damp) is chosen when:<br />
** <rule here><br />
<br />
Example sentences<br />
* basá is chosen in the following example:<br />
** <example here><br />
* máan is chosen in the following example:<br />
** <example here><br />
<br />
<br />
[[Category:Sp17_LexicalSelection]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Bikol_and_Chamorro/Lexical_Selection&diff=4268Bikol and Chamorro/Lexical Selection2017-04-04T16:19:51Z<p>Ltarlin1: </p>
<hr />
<div>== bcl → cha Evaluation ==<br />
<br />
==== bóla ====<br />
In Bikol, <b>bóla</b> means ball or compliment. In Chamorro, ball = <i>bola</i> and compliment = <i>komplimenta</i>.<br />
<br />
Lexical selection between bola and komplimenta is guided by the following rules:<br />
* Bola (ball) is chosen when:<br />
** Preceded by a verb such as throw, toss, catch, play, buy, borrow, lend, bounce<br />
** Followed by an adjective such as round, colors<br />
<br />
Example sentences<br />
* Bola (ball) is chosen in the following example:<br />
** Sublion mo si bola ki Jose (<u>Borrow</u> the <i>ball</i> from Jacob)<br />
* Komplimenta (compliment) is chosen in the following example:<br />
** <example here><br />
<br />
==== glóbo ====<br />
In Bikol, <b>glóbo</b> means map or balloon. In Chamorro, map = <i>mapa</i> and balloon = <i>abubu</i>.<br />
<br />
For now, the default selection is set to translate glóbo to abubu, or balloon in English.<br />
== cha → bcl Evalutaion ==<br />
In Chamorro, <b>guakse</b> means to scrub (clothes) or to turn inside out. In Bikol, to scrub (clothes) = <i>kuró-kusó</i> and to turn inside out = <i>balík</i>.<br />
<br />
Lexical selection between kuró-kusó and balí̈ is guided by the following rules:<br />
* Bola (ball) is chosen when:<br />
** Preceded by a verb such as throw, toss, catch, play, buy, borrow, lend, bounce<br />
** Followed by an adjective such as round, colors<br />
<br />
Example sentences<br />
* Bola (ball) is chosen in the following example:<br />
** Sublion mo si bola ki Jose (<u>Borrow</u> the <i>ball</i> from Jacob)<br />
* Komplimenta (compliment) is chosen in the following example:<br />
** <example here><br />
<br />
<br />
<br />
<br />
* <b>maggem</b> means cautious or damp. In Bikol, <i>máan</i> means cautious and <i>basá</i> means damp.<br />
[[Category:Sp17_LexicalSelection]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Bikol_and_Chamorro/Lexical_Selection&diff=4261Bikol and Chamorro/Lexical Selection2017-04-04T16:01:15Z<p>Ltarlin1: </p>
<hr />
<div>== bcl → cha Evaluation ==<br />
<br />
==== bóla ====<br />
In Bikol, <b>bóla</b> means ball or compliment. In Chamorro, ball = <i>bola</i> and compliment = <i>komplimenta</i>.<br />
<br />
Lexical selection between bola and komplimenta is guided by the following rules:<br />
* Bola (ball) is chosen when:<br />
** Preceded by a verb such as throw, toss, catch, play, buy, borrow, lend, bounce<br />
** Followed by an adjective such as round, colors<br />
<br />
Example sentences<br />
* Bola (ball) is chosen in the following example:<br />
** Sublion mo si bola ki Jose (<u>Borrow</u> the <i>ball</i> from Jacob)<br />
* Komplimenta (compliment) is chosen in the following example:<br />
** <example here><br />
<br />
==== glóbo ====<br />
In Bikol, <b>glóbo</b> means map or balloon. In Chamorro, map = <i>mapa</i> and balloon = <i>abubu</i>.<br />
<br />
For now, the default selection is set to translate glóbo to abubu, or balloon in English.<br />
== cha → bcl Evalutaion ==<br />
<br />
* In Chamorro, <b>guakse</b> means to scrub (clothes) or to turn inside out. In Bikol, to scrub (clothes) is <i>kuró-kusó</i> and to turn inside out is <i>balík</i>.<br />
* <b>maggem</b> means cautious or damp. In Bikol, <i>máan</i> means cautious and <i>basá</i> means damp.<br />
[[Category:Sp17_LexicalSelection]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Bikol_and_Chamorro/Lexical_Selection&diff=4183Bikol and Chamorro/Lexical Selection2017-03-30T16:34:29Z<p>Ltarlin1: </p>
<hr />
<div>== bcl → cha Evalutaion ==<br />
<br />
<br />
== cha → bcl Evalutaion ==<br />
<br />
<br />
[[Category:Sp17_LexicalSelection]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Bikol_and_Chamorro&diff=4182Bikol and Chamorro2017-03-30T16:33:24Z<p>Ltarlin1: /* Developed Resources */</p>
<hr />
<div>Resources for machine translation between Bikol and Chamorro<br />
* [https://wikis.swarthmore.edu/ling073/Bikol Bikol]<br />
* [https://wikis.swarthmore.edu/ling073/Chamorro Chamorro]<br />
<br />
== Developed Resources ==<br />
* [https://wikis.swarthmore.edu/ling073/Bikol_and_Chamorro/Contrastive_Grammar Contrastive Grammar]<br />
* [https://wikis.swarthmore.edu/ling073/Bikol_and_Chamorro/Lexical_Selection Lexical Selection]<br />
<br />
== Translation Repositories ==<br />
* [https://github.swarthmore.edu/ltarlin1/ling073-bcl-cha Bikol to Chamorro translation]<br />
* [https://github.swarthmore.edu/eortici1/ling073-cha-bcl Chamorro to Bikol translation]<br />
<br />
== bcl → cha Evalutaion ==<br />
* WER = 94.74%<br />
* PER = 84.21%<br />
* Proportion of stems translated correctly = 100.00%<br />
<br />
== cha → bcl Evaluation ==<br />
* WER = 90.91%<br />
* PER = 86.36%<br />
* Proportion of stems translated correctly = 100.00%<br />
<br />
== Lexical Selection ==<br />
Find at least two cases in each direction of a one-to-many mapping.<br />
<br />
=== Bikol-Chamorro ===<br />
==== bóla ====<br />
In Bikol, <b>bóla</b> means ball or compliment. In Chamorro, ball = <i>bola</i> and compliment = <i>komplimenta</i>.<br />
<br />
Lexical selection between bola and komplimenta is guided by the following rules:<br />
* Bola (ball) is chosen when:<br />
** Preceded by a verb such as throw, toss, catch, play, buy, borrow, lend, bounce<br />
** Followed by an adjective such as round, colors<br />
<br />
==== glóbo ====<br />
In Bikol, <b>glóbo</b> means map or balloon. In Chamorro, map = <i>mapa</i> and balloon = <i>abubu</i>.<br />
<br />
For now, the default selection is set to translate glóbo to abubu, or balloon in English.<br />
<br />
=== Chamorro-Bikol ===<br />
* In Chamorro, <b>guakse</b> means to scrub (clothes) or to turn inside out. In Bikol, to scrub (clothes) is <i>kuró-kusó</i> and to turn inside out is <i>balík</i>.<br />
* <b>maggem</b> means cautious or damp. In Bikol, <i>máan</i> means cautious and <i>basá</i> means damp.<br />
<br />
<br />
<br />
<!--<br />
== List of extra words ==<br />
Nouns:<br />
*basúra: garbage<br />
*garáhe: garage <-------didnʼt have<br />
*matemátika: mathematics<br />
*dungó: nose<br />
*pasénsia: patience<br />
*bolsá: pocket<br />
*hílo: poison<br />
*lamésa: table<br />
*pábo: turkey<br />
*dága: knife<br />
*púso: heart<br />
*lalawgón: face<br />
*kolór: color<br />
*kapé: coffee<br />
*báybáy: coast<br />
*bádo: clothes<br />
*inápay: bread<br />
<br />
Verbs:<br />
*luwás: to exit, to leave<br />
*apód: to call (someone)<br />
*sublí: to borrow<br />
*hatód: to bring, to deliver<br />
*será: to close<br />
*kagrít: to scream<br />
*bakál: to shop <-------didnʼt have<br />
*tarám: to talk<br />
*halát: to wait<br />
*matá: to wake up<br />
*búhay: to live<br />
*taó: to give<br />
*dekorár: to decorate<br />
*bítbít: to carry<br />
<br />
== Other possible lexical selection options ==<br />
* bulan: moon, month (110)<br />
* dali (ma-): quickly, easily (123)<br />
* dampog: foggy, moist (124)<br />
* delikado: delicate, dangerous (129)<br />
* duros (ma-): windy, breezy; boastful *** guaifon, <br />
* gabat: heavy, grievous (154)<br />
* gana: enthusiasm, appetite (156)<br />
* grado: grade (temp.) and grade (1st grade) (164)<br />
gugu (165)<br />
gurano (167)<br />
gusto (168)<br />
gutos (169)<br />
<br />
== Notes for Evan ==<br />
* typo in first line of Test 1 - Chamorro word should be "linulí"<br />
* is the accent supposed to be over the > sign? Is that just a weird rendering thing that doesn't actually matter?<br />
* Test 2 line 2 - the root is actually "gumaʼ", weʼll add the suffix and vowel change in a later step<br />
* Test 3 line 1 - accent looks like it's in the wrong place on maéstro<br />
* Test 3 line 1 - again, the root is just "maʼestro" and the prefix will be added later<br />
* Test 5 line 1 - root is "metgot"<br />
* I put all the above words (except "garage" and "to shop") into the bcl-cha dix file. Youʼll have to put them in the cha-bcl file (unless you did already) the same way but switched left and right. We also have to add them to our respective lexc files eventually as well<br />
<br />
== Notes for Lee ==<br />
* Test 1, iinulí should be ulí<br />
* Test 4, nagdumán should be dumán<br />
* Test 5, makusóg should be kusóg<br />
<br />
--><br />
<br />
[[Category:Sp17_TranslationPairs]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Bikol_and_Chamorro&diff=4181Bikol and Chamorro2017-03-30T16:33:11Z<p>Ltarlin1: </p>
<hr />
<div>Resources for machine translation between Bikol and Chamorro<br />
* [https://wikis.swarthmore.edu/ling073/Bikol Bikol]<br />
* [https://wikis.swarthmore.edu/ling073/Chamorro Chamorro]<br />
<br />
== Developed Resources ==<br />
* [https://wikis.swarthmore.edu/ling073/Bikol_and_Chamorro/Contrastive_Grammar Contrastive Grammar]<br />
* [https://wikis.swarthmore.edu/ling073/Bikol_and_Chamorro/Lexical_Selection]<br />
<br />
== Translation Repositories ==<br />
* [https://github.swarthmore.edu/ltarlin1/ling073-bcl-cha Bikol to Chamorro translation]<br />
* [https://github.swarthmore.edu/eortici1/ling073-cha-bcl Chamorro to Bikol translation]<br />
<br />
== bcl → cha Evalutaion ==<br />
* WER = 94.74%<br />
* PER = 84.21%<br />
* Proportion of stems translated correctly = 100.00%<br />
<br />
== cha → bcl Evaluation ==<br />
* WER = 90.91%<br />
* PER = 86.36%<br />
* Proportion of stems translated correctly = 100.00%<br />
<br />
== Lexical Selection ==<br />
Find at least two cases in each direction of a one-to-many mapping.<br />
<br />
=== Bikol-Chamorro ===<br />
==== bóla ====<br />
In Bikol, <b>bóla</b> means ball or compliment. In Chamorro, ball = <i>bola</i> and compliment = <i>komplimenta</i>.<br />
<br />
Lexical selection between bola and komplimenta is guided by the following rules:<br />
* Bola (ball) is chosen when:<br />
** Preceded by a verb such as throw, toss, catch, play, buy, borrow, lend, bounce<br />
** Followed by an adjective such as round, colors<br />
<br />
==== glóbo ====<br />
In Bikol, <b>glóbo</b> means map or balloon. In Chamorro, map = <i>mapa</i> and balloon = <i>abubu</i>.<br />
<br />
For now, the default selection is set to translate glóbo to abubu, or balloon in English.<br />
<br />
=== Chamorro-Bikol ===<br />
* In Chamorro, <b>guakse</b> means to scrub (clothes) or to turn inside out. In Bikol, to scrub (clothes) is <i>kuró-kusó</i> and to turn inside out is <i>balík</i>.<br />
* <b>maggem</b> means cautious or damp. In Bikol, <i>máan</i> means cautious and <i>basá</i> means damp.<br />
<br />
<br />
<br />
<!--<br />
== List of extra words ==<br />
Nouns:<br />
*basúra: garbage<br />
*garáhe: garage <-------didnʼt have<br />
*matemátika: mathematics<br />
*dungó: nose<br />
*pasénsia: patience<br />
*bolsá: pocket<br />
*hílo: poison<br />
*lamésa: table<br />
*pábo: turkey<br />
*dága: knife<br />
*púso: heart<br />
*lalawgón: face<br />
*kolór: color<br />
*kapé: coffee<br />
*báybáy: coast<br />
*bádo: clothes<br />
*inápay: bread<br />
<br />
Verbs:<br />
*luwás: to exit, to leave<br />
*apód: to call (someone)<br />
*sublí: to borrow<br />
*hatód: to bring, to deliver<br />
*será: to close<br />
*kagrít: to scream<br />
*bakál: to shop <-------didnʼt have<br />
*tarám: to talk<br />
*halát: to wait<br />
*matá: to wake up<br />
*búhay: to live<br />
*taó: to give<br />
*dekorár: to decorate<br />
*bítbít: to carry<br />
<br />
== Other possible lexical selection options ==<br />
* bulan: moon, month (110)<br />
* dali (ma-): quickly, easily (123)<br />
* dampog: foggy, moist (124)<br />
* delikado: delicate, dangerous (129)<br />
* duros (ma-): windy, breezy; boastful *** guaifon, <br />
* gabat: heavy, grievous (154)<br />
* gana: enthusiasm, appetite (156)<br />
* grado: grade (temp.) and grade (1st grade) (164)<br />
gugu (165)<br />
gurano (167)<br />
gusto (168)<br />
gutos (169)<br />
<br />
== Notes for Evan ==<br />
* typo in first line of Test 1 - Chamorro word should be "linulí"<br />
* is the accent supposed to be over the > sign? Is that just a weird rendering thing that doesn't actually matter?<br />
* Test 2 line 2 - the root is actually "gumaʼ", weʼll add the suffix and vowel change in a later step<br />
* Test 3 line 1 - accent looks like it's in the wrong place on maéstro<br />
* Test 3 line 1 - again, the root is just "maʼestro" and the prefix will be added later<br />
* Test 5 line 1 - root is "metgot"<br />
* I put all the above words (except "garage" and "to shop") into the bcl-cha dix file. Youʼll have to put them in the cha-bcl file (unless you did already) the same way but switched left and right. We also have to add them to our respective lexc files eventually as well<br />
<br />
== Notes for Lee ==<br />
* Test 1, iinulí should be ulí<br />
* Test 4, nagdumán should be dumán<br />
* Test 5, makusóg should be kusóg<br />
<br />
--><br />
<br />
[[Category:Sp17_TranslationPairs]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Bikol_and_Chamorro/Lexical_Selection&diff=4180Bikol and Chamorro/Lexical Selection2017-03-30T16:32:40Z<p>Ltarlin1: Created page with " Category:Sp17_LexicalSelection"</p>
<hr />
<div><br />
<br />
<br />
[[Category:Sp17_LexicalSelection]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Bikol_and_Chamorro&diff=4167Bikol and Chamorro2017-03-30T16:06:48Z<p>Ltarlin1: /* cha → bcl Evaluation */</p>
<hr />
<div>Resources for machine translation between Bikol and Chamorro<br />
* [https://wikis.swarthmore.edu/ling073/Bikol Bikol]<br />
* [https://wikis.swarthmore.edu/ling073/Chamorro Chamorro]<br />
<br />
== Developed Resources ==<br />
* [https://wikis.swarthmore.edu/ling073/Bikol_and_Chamorro/Contrastive_Grammar Contrastive Grammar]<br />
<br />
== Translation Repositories ==<br />
* [https://github.swarthmore.edu/ltarlin1/ling073-bcl-cha Bikol to Chamorro translation]<br />
* [https://github.swarthmore.edu/eortici1/ling073-cha-bcl Chamorro to Bikol translation]<br />
<br />
== bcl → cha Evalutaion ==<br />
* WER = 94.74%<br />
* PER = 84.21%<br />
* Proportion of stems translated correctly = 100.00%<br />
<br />
== cha → bcl Evaluation ==<br />
* WER = 90.91%<br />
* PER = 86.36%<br />
* Proportion of stems translated correctly = 100.00%<br />
<br />
== Lexical Selection ==<br />
Find at least two cases in each direction of a one-to-many mapping.<br />
<br />
=== Bikol-Chamorro ===<br />
==== bóla ====<br />
In Bikol, <b>bóla</b> means ball or compliment. In Chamorro, ball = <i>bola</i> and compliment = <i>komplimenta</i>.<br />
<br />
Lexical selection between bola and komplimenta is guided by the following rules:<br />
* Bola (ball) is chosen when:<br />
** Preceded by a verb such as throw, toss, catch, play, buy, borrow, lend<br />
** Followed by an adjective such as round, bouncy, colors<br />
<br />
==== glóbo ====<br />
In Bikol, <b>glóbo</b> means map or balloon. In Chamorro, map = <i>mapa</i> and balloon = <i>abubu</i>.<br />
<br />
For now, the default selection is set to translate glóbo to abubu, or balloon in English.<br />
<br />
<br />
=== Chamorro-Bikol ===<br />
* In Chamorro, <b>guakse</b> means to scrub (clothes) or to turn inside out. In Bikol, to scrub (clothes) is <i>kuró-kusó</i> and to turn inside out is <i>balík</i>.<br />
* <b>maggem</b> means cautious or damp. In Bikol, <i>máan</i> means cautious and <i>basá</i> means damp.<br />
<br />
<br />
<br />
<!--<br />
== List of extra words ==<br />
Nouns:<br />
*basúra: garbage<br />
*garáhe: garage <-------didnʼt have<br />
*matemátika: mathematics<br />
*dungó: nose<br />
*pasénsia: patience<br />
*bolsá: pocket<br />
*hílo: poison<br />
*lamésa: table<br />
*pábo: turkey<br />
*dága: knife<br />
*púso: heart<br />
*lalawgón: face<br />
*kolór: color<br />
*kapé: coffee<br />
*báybáy: coast<br />
*bádo: clothes<br />
*inápay: bread<br />
<br />
Verbs:<br />
*luwás: to exit, to leave<br />
*apód: to call (someone)<br />
*sublí: to borrow<br />
*hatód: to bring, to deliver<br />
*será: to close<br />
*kagrít: to scream<br />
*bakál: to shop <-------didnʼt have<br />
*tarám: to talk<br />
*halát: to wait<br />
*matá: to wake up<br />
*búhay: to live<br />
*taó: to give<br />
*dekorár: to decorate<br />
*bítbít: to carry<br />
<br />
== Other possible lexical selection options ==<br />
* bulan: moon, month (110)<br />
* dali (ma-): quickly, easily (123)<br />
* dampog: foggy, moist (124)<br />
* delikado: delicate, dangerous (129)<br />
* duros (ma-): windy, breezy; boastful *** guaifon, <br />
* gabat: heavy, grievous (154)<br />
* gana: enthusiasm, appetite (156)<br />
* grado: grade (temp.) and grade (1st grade) (164)<br />
gugu (165)<br />
gurano (167)<br />
gusto (168)<br />
gutos (169)<br />
<br />
== Notes for Evan ==<br />
* typo in first line of Test 1 - Chamorro word should be "linulí"<br />
* is the accent supposed to be over the > sign? Is that just a weird rendering thing that doesn't actually matter?<br />
* Test 2 line 2 - the root is actually "gumaʼ", weʼll add the suffix and vowel change in a later step<br />
* Test 3 line 1 - accent looks like it's in the wrong place on maéstro<br />
* Test 3 line 1 - again, the root is just "maʼestro" and the prefix will be added later<br />
* Test 5 line 1 - root is "metgot"<br />
* I put all the above words (except "garage" and "to shop") into the bcl-cha dix file. Youʼll have to put them in the cha-bcl file (unless you did already) the same way but switched left and right. We also have to add them to our respective lexc files eventually as well<br />
<br />
== Notes for Lee ==<br />
* Test 1, iinulí should be ulí<br />
* Test 4, nagdumán should be dumán<br />
* Test 5, makusóg should be kusóg<br />
<br />
--><br />
<br />
[[Category:Sp17_TranslationPairs]]</div>Ltarlin1http://wikis.swarthmore.edu/ling073/index.php?title=Bikol_and_Chamorro/Lexical_selection&diff=4064Bikol and Chamorro/Lexical selection2017-03-28T16:08:05Z<p>Ltarlin1: </p>
<hr />
<div>== bcl → cha ==<br />
* In Bikol, <b>bóla</b> means ball or compliment. In Chamorro, ball = <i>bola</i> and compliment = <i>komplimenta</i>.<br />
* <b>glóbo</b> means map or balloon in Bikol. In Chamorro, map = <i>mapa</i> and balloon = <i>abubu</i>.<br />
<br />
== cha → bcl ==<br />
* In Chamorro, <b>guakse</b> means to scrub (clothes) or to turn inside out. In Bikol, to scrub (clothes) is <i>kuró-kusó</i> and to turn inside out is <i>balík</i>.<br />
* <b>maggem</b> means cautious or damp. In Bikol, <i>máan</i> means cautious and <i>basá</i> means damp.</div>Ltarlin1