Overview
In the remaining weeks of the class, you will be focusing on the final project. Assignments and Homeworks are now completed, and the Readings have been shifted to benefit your projects. The final project is a team-based, sketch-centric assignment which includes several deliverables that will be discussed below.
Deliverables
Following Assignment 7 and the in-class discussions, everyone should now be a member of a team with a total of 12 teams in all.
The final project may be broken down into three deliverables:
(1) Project Code - Since this is a computer science class, you need to build a program, website, or some form of software tool as part of the final project. The language, data sources, interface, etc. are up to you and your team. It is worth noting that using the paper.js canvas available on the shared class drive and your previous homework assignments, every team has a working, real-time sketch canvas with corner detection and simple recognition already built in Javascript.
The Project Code will need to be documented with some sort of ReadMe file and information about building and using the code. Email a ZIP of all the code together or provide a link to a GitHub project, just submit the entire code source in some form.
(2) Project Report - Alongside the application itself, you need to be able to communicate your project. A written paper should be submitted in the SIGCHI 2016 format. You may obtain a Word or LaTex template in this format by downloading this repository as a ZIP file. The template will provide some useful section suggestions, but a typical paper should include an Introduction, Prior Work, Methodology, Evaluation, and Conclusion. These exact sections are not necessary but the content corresponding to background, explanation of your project, and how you tested it should be in the paper.
The Project Report should be at least 8 pages. Also, you must have at least 8 citations per team member. Thus, a team with 3 people needs 24 citations at a minimum. There is no maximum on the number of pages or citations.
(3) Project Presentation - Another import part of communicating your project is the final presentation. This consists of a 15 minute oral presentation. The content should roughly correspond to your paper: background and what's been done before, what you have done, and how you evaluated it.
The Project Presentation must include a demo video. You can speak over it in the live presentation, but having a standalone demo video with its own narration will be important for the final submission. The presentation slides will need to be submitted as well.
Due Date
All of the project files must be submitted by midnight on the last day of finals, December 15. This consists of the code from (1), the report from (2), and the presentation + video demo from (3). Only one submission is necessary per team.
The Project Presentations will take place on the last day of class, December 7, and the schedule final exam time, December 14. Three teams will present on Dec. 7 with the remaining nine presenting on Dec. 14. The slots for Dec. 7 are available on a first-come first-serve basis, so email to obtain one of these slots as soon as possible if you are interested in finishing early.
Saturday, November 12, 2016
Readings 18 to 25 - Project Readings
Overview
We have now completed the assigned readings portion of the course. At this point, you should turn your attention to your final project and focus on finding reading materials to strengthen your work and project report. To further this goal, all future reading assignments are self-directed.
Project Readings
You should select 8 papers related to your project and blog about them. You may reuse some of the papers you explored in Assignment 6. If your project plan has changed or your find more relevant works to include, you are encouraged to select those as well.
If you are on a team, it will be beneficial to find different papers than your teammates. This is because your final report requires a minimum number of citations based on your team size and having the readings done for the blog assignment will simplify this task so long as each person has read their own papers.
Due Dates
The standard reading schedule is not impacted by the shift to project readings. You will continue to post summaries to your blogs by Sundays; the only difference is that the readings are no longer pre-selected and you must choose your own. The 8 project readings correspond directly to the typical M/W/F schedule we have been following for assigned readings. The timeline is as follows:
11/11, 11/14, 11/16 (Readings 18, 19, and 20) due 11/20
11/18, 11/21, 11/23 (Readings 21, 22, and 23) due 11/27
11/28, 11/30 (Readings 24 and 25) due 12/04
Monday, November 7, 2016
Reading 17 - ChemInk
Paper
Ouyang, Tom Y., and Randall Davis. "ChemInk: a natural real-time recognition system for chemical drawings." Proceedings of the 16th international conference on Intelligent user interfaces. ACM, 2011.
Notes
Now that all of the homework assignments are complete, we are shifting the class focus towards the final project. In line with that plan, we have several system-oriented papers which will be useful preparation for your own project development and final report. In this work, Ouyang and Davis describe an interface for recognizing chemical diagrams.
Tuesday, November 1, 2016
Reading 16 - No Rubine?
Paper
Paulson, Brandon, et al. "What!?! no Rubine features?: using geometric-based features to produce normalized confidence values for sketch recognition." HCC Workshop: Sketch Tools for Diagramming. 2008.
Notes
This is another recognition paper which discusses a system based on a hybrid approach to achieve its recognition rates.
Paulson, Brandon, et al. "What!?! no Rubine features?: using geometric-based features to produce normalized confidence values for sketch recognition." HCC Workshop: Sketch Tools for Diagramming. 2008.
Notes
This is another recognition paper which discusses a system based on a hybrid approach to achieve its recognition rates.
Friday, October 28, 2016
Assignment 7 - Project Proposal
Overview
We have completed the homework portion of the class and covered a majority of the readings, so it is time to start finalizing plans for the project. In Assignment 5, you started thinking about ideas, and in Assignment 6 you explored these ideas a little bit in terms of their novelty and applicability. You now will form a team and build your refined proposal. You have the last month-and-a-half of class to complete the final project, but we would like for you to be able to get started as soon as possible once November begins.
Instructions
Write a paragraph describing your project proposal. You should discuss what you want to do, why you want to do it, and how you plan to accomplish it. Roughly, this corresponds to the idea, the motivation, and the project plan. If you need more than a paragraph, that is fine, but if you need only a few sentences to describe each, a paragraph is sufficient.
At the end, state whether you are working alone or on a team, and if you are on a team, list the team members.
Post this proposal to your blog by the due date. Only one member of each team needs to post the proposal itself, but if you are a team member, you should create a post that links to the team's proposal and states your intention to work on the project.
If you need help forming a team, a spreadsheet has been placed in the class drive. I encourage team leaders who have an idea post their name and a short summary of their idea to this spreadsheet. That will help you find members, since those who are looking for a team are encouraged to sign up in the team slots that interest them. We can finalize teams some time next week; this is just to help get your ideas out there and express your interests.
Due Date
Nov. 7, Monday @ Midnight
25% deducted per day late
We have completed the homework portion of the class and covered a majority of the readings, so it is time to start finalizing plans for the project. In Assignment 5, you started thinking about ideas, and in Assignment 6 you explored these ideas a little bit in terms of their novelty and applicability. You now will form a team and build your refined proposal. You have the last month-and-a-half of class to complete the final project, but we would like for you to be able to get started as soon as possible once November begins.
Instructions
Write a paragraph describing your project proposal. You should discuss what you want to do, why you want to do it, and how you plan to accomplish it. Roughly, this corresponds to the idea, the motivation, and the project plan. If you need more than a paragraph, that is fine, but if you need only a few sentences to describe each, a paragraph is sufficient.
At the end, state whether you are working alone or on a team, and if you are on a team, list the team members.
Post this proposal to your blog by the due date. Only one member of each team needs to post the proposal itself, but if you are a team member, you should create a post that links to the team's proposal and states your intention to work on the project.
If you need help forming a team, a spreadsheet has been placed in the class drive. I encourage team leaders who have an idea post their name and a short summary of their idea to this spreadsheet. That will help you find members, since those who are looking for a team are encouraged to sign up in the team slots that interest them. We can finalize teams some time next week; this is just to help get your ideas out there and express your interests.
Obtaining Credit
You should have a blog post corresponding to Assignment 7 by the due date. You need either a project proposal or a link to a project proposal stating that you are working on that team.
Due Date
Nov. 7, Monday @ Midnight
25% deducted per day late
Monday, October 24, 2016
Reading 15 - Tahuti
Paper
Hammond, Tracy, and Randall Davis. "Tahuti: A geometrical sketch recognition system for uml class diagrams." ACM SIGGRAPH 2006 Courses. ACM, 2006.
Notes
Tahuti is a system for recognizing UML diagrams and automatically generating code. It includes some very simple and intuitive geometric recognition methods, including an algorithm for arrow recognition.
Hammond, Tracy, and Randall Davis. "Tahuti: A geometrical sketch recognition system for uml class diagrams." ACM SIGGRAPH 2006 Courses. ACM, 2006.
Notes
Tahuti is a system for recognizing UML diagrams and automatically generating code. It includes some very simple and intuitive geometric recognition methods, including an algorithm for arrow recognition.
Monday, October 17, 2016
Reading 14 - LADDER
Paper
Hammond, Tracy, and Randall Davis. "LADDER, a sketching language for user interface developers." Computers & Graphics 29.4 (2005): 518-532.
Notes
LADDER is a sketch language for defining geometric-based relationships that allow recognition of shapes from any domain.
Hammond, Tracy, and Randall Davis. "LADDER, a sketching language for user interface developers." Computers & Graphics 29.4 (2005): 518-532.
Notes
LADDER is a sketch language for defining geometric-based relationships that allow recognition of shapes from any domain.
Friday, October 14, 2016
Reading 13 - Paleosketch
Paper
Paulson, Brandon, and Tracy Hammond. "Paleosketch: accurate primitive sketch recognition and beautification." Proceedings of the 13th international conference on Intelligent user interfaces. ACM, 2008.
Notes
Paleosketch is a good primitive recognition engine which supports many different types of shapes. Not only does this paper include a number of useful shape test algorithms, it also introduces two new features common in sketch recognition today -- the Normalized Distance between Direction Extremes (NDDE) and the Direction Change Ratio (DCR).
Paulson, Brandon, and Tracy Hammond. "Paleosketch: accurate primitive sketch recognition and beautification." Proceedings of the 13th international conference on Intelligent user interfaces. ACM, 2008.
Notes
Paleosketch is a good primitive recognition engine which supports many different types of shapes. Not only does this paper include a number of useful shape test algorithms, it also introduces two new features common in sketch recognition today -- the Normalized Distance between Direction Extremes (NDDE) and the Direction Change Ratio (DCR).
Wednesday, October 12, 2016
Homework 3 - Recognition
Overview
For the third and final homework assignment, before we turn our attention to the project, we will look at building sketch recognition algorithms. By now you have implemented feature extraction and corner-finding/segmentation methods. We will build on this experience to perform recognition.
Instructions
Languages and Data
As in Homework 2, you are not required to use any specific language, but the data is only available via the Sketch Recognition Library Database (srlib_db), so you will at least need to make calls to the service and parse the JSON files. If you have completed Homework 2 in any language, you will have code to handle these operations.
The data handlers for srlib_db are available in Javascript via srlib_js, which is included in a limited form in the Starter code available on the class drive under "Homework 3". The documentation for srlib_js is also included in "srlib_jsdoc"; it is a JSDoc directory and should be downloaded and read through a web browser by opening the "index.html" inside "srlib_jsdoc".
The specification of SketchML::JSON, which is the format of all sketches on srlib_db, is also available in the homework's folder. If you wish to use another language, that will be a useful reference, but any language that handles JSON-like objects natively will be easy to adapt.
Recognition
The goal of this assignment is that, given a set of processed strokes, you can group them into meaningful, recognized shapes. Specifically, you should be able to recognize "arrow" and "truss" shapes from the substrokes. You may use your pre-existing code for feature extraction and segmentation (from Homeworks 1 and 2, respectively) if you wish. Alternatively, you may directly use the substrokes provided by the Mechanix data; for this assignment, only the shape data has been removed, while both shapes and substrokes were removed in the previous assignment. As mentioned in the previous assignment, if you performed some additional effort in Homework 2 to identify nodes, that could be useful in your recognition of trusses in this assignment if you want to use your own segmenter.
You may implement any recognition method you like except template matching. Such a method does not scale to trusses of any number of nodes, nor does it handle the many variations of drawing arrows very well. It may be possible to perform fairly well in this specific domain on very specific examples with template matching, but it is heavily discouraged because of the lack of scalability. We will be covering more recognition methods over the next two weeks in class, and you are encouraged to explore your own ideas for sketch recognition algorithms. Any exploration and implementation you do during this assignment will likely benefit your final project.
As before, evaluation code and details will be shared soon. Placeholder text has been added to the Starter code so that only the function will need to be added. Your shapes will be evaluated against other types of shapes (e.g. triangles, letters, generic closed bodies, etc.), so be sure your algorithm is robust enough to detect true negatives. That is, do not assume that you can label every shape as an arrow or a truss simply because there are so many in the Mechanix data; that will lead to many false positives on test data.
Starter Code
As with Homeworks 1 and 2, there is provided Starter code in the directory for Homework 3. This file already handles loading data and converting it into the appropriate format. It also visualizes the original sketch data, prefixed "old", and your sketch data, prefixed "new", according to either the substrokes or shapes.
When plotting substrokes, each substroke is assigned a random color to easily differentiate them on the canvas. Substrokes are identical for "old" and "new" in the current version, as strokes were in the previous homework, although you may use your own segmenter if desired. When plotting shapes, the entire shape is given the same random color. The "old" sketches will have correctly segmented (by Mechanix) shapes, which will be the basis for comparison of your "new" sketch shapes. The Starter code simply makes all substrokes part of one shape at the moment in order to demonstrate some useful functions of srlib_js. Once finished, your "new" sketches should also feature multiple shapes for the different recognized objects.
Note that Mechanix sketches can be large and may get cut off by the canvas.
Obtaining Credit
Again, the goal of this assignment is that you write sketch recognition algorithms for arrows and trusses. You will need to submit all of your source files to the grader. Also, include a small report describing what algorithm you implemented, the intuition of how it works, and the most difficult problems you encountered. If you run the metrics code, include those numbers as well.
Please ZIP all your files together into a single file submission titled "HW3_<last name>_<first initial>.zip". Since the university may block ZIP files, it is recommended that you upload your file to Google Drive and share the link via email.
More details will follow regarding the evaluation metrics. Remember to keep false positives and true negatives in mind so that your algorithm can perform well on general test data.
This homework may seem large, but given the previous experience and code you've developed from homeworks 1 and 2, it should be quite manageable. You will have approximately two weeks to complete the assignment before we switch over to project-centered tasks for the final half of the class.
Please ZIP all your files together into a single file submission titled "HW3_<last name>_<first initial>.zip". Since the university may block ZIP files, it is recommended that you upload your file to Google Drive and share the link via email.
More details will follow regarding the evaluation metrics. Remember to keep false positives and true negatives in mind so that your algorithm can perform well on general test data.
This homework may seem large, but given the previous experience and code you've developed from homeworks 1 and 2, it should be quite manageable. You will have approximately two weeks to complete the assignment before we switch over to project-centered tasks for the final half of the class.
Due Date
Nov. 2, Wednesday @ Midnight (extended from Oct. 26)
25% deducted per day late
Reading 12 - Electronic Cocktail Napkin
Paper
Gross, Mark D. "Recognizing and interpreting diagrams in design." Proceedings of the workshop on Advanced visual interfaces. ACM, 1994.
Notes
This is another simple recognition method which relies on template codes against which to match.
Gross, Mark D. "Recognizing and interpreting diagrams in design." Proceedings of the workshop on Advanced visual interfaces. ACM, 1994.
Notes
This is another simple recognition method which relies on template codes against which to match.
Monday, October 10, 2016
Reading 11 - $1 Recognizer
Paper
Wobbrock, Jacob O., Andrew D. Wilson, and Yang Li. "Gestures without libraries, toolkits or training: a $1 recognizer for user interface prototypes." Proceedings of the 20th annual ACM symposium on User interface software and technology. ACM, 2007.
Notes
We have now finished the corner finding portion of readings and will be moving on to recognition in preparation for the next homework. The recognition portion begins with the most simple recognition algorithm, which is often used as a baseline for error evaluation. This is the $1 algorithm -- template matching. In this paper, the authors present a method for finding the optimal matching shape/template using the distance between the drawn shape and the template. There are many variants of $1, e.g. $N, $P, $3, etc., but all of them are based on the same idea of resampling into a cloud of points and finding the distances between drawn shapes and templates. Dealing with rotation differs slightly between methods, such as using polar coordinates to handle minimizing rotation, but overall, the idea is the same. Following this introduction into recognition, we'll start exploring more specific methods.
Wobbrock, Jacob O., Andrew D. Wilson, and Yang Li. "Gestures without libraries, toolkits or training: a $1 recognizer for user interface prototypes." Proceedings of the 20th annual ACM symposium on User interface software and technology. ACM, 2007.
Notes
We have now finished the corner finding portion of readings and will be moving on to recognition in preparation for the next homework. The recognition portion begins with the most simple recognition algorithm, which is often used as a baseline for error evaluation. This is the $1 algorithm -- template matching. In this paper, the authors present a method for finding the optimal matching shape/template using the distance between the drawn shape and the template. There are many variants of $1, e.g. $N, $P, $3, etc., but all of them are based on the same idea of resampling into a cloud of points and finding the distances between drawn shapes and templates. Dealing with rotation differs slightly between methods, such as using polar coordinates to handle minimizing rotation, but overall, the idea is the same. Following this introduction into recognition, we'll start exploring more specific methods.
Friday, October 7, 2016
Reading 10 - Yu Corners
Paper
Yu, Bo, and Shijie Cai. "A domain-independent system for sketch recognition." Proceedings of the 1st international conference on Computer graphics and interactive techniques in Australasia and South East Asia. ACM, 2003.
Notes
Continuing on our readings in corner finding before we progress on to primitive recognition and other methods.
Yu, Bo, and Shijie Cai. "A domain-independent system for sketch recognition." Proceedings of the 1st international conference on Computer graphics and interactive techniques in Australasia and South East Asia. ACM, 2003.
Notes
Continuing on our readings in corner finding before we progress on to primitive recognition and other methods.
Wednesday, October 5, 2016
Reading 9 - Combining Corners
Paper
Wolin, Aaron, Martin Field, and Tracy Hammond. "Combining corners from multiple segmenters." Proceedings of the Eighth Eurographics Symposium on Sketch-Based Interfaces and Modeling. ACM, 2011.
Notes
Another paper in corner finding, we look at a method of combining multiple different techniques into a better, more flexible segmenter.
Wolin, Aaron, Martin Field, and Tracy Hammond. "Combining corners from multiple segmenters." Proceedings of the Eighth Eurographics Symposium on Sketch-Based Interfaces and Modeling. ACM, 2011.
Notes
Another paper in corner finding, we look at a method of combining multiple different techniques into a better, more flexible segmenter.
Sunday, October 2, 2016
Homework 2 - Segmentation
Overview
Following on our previous assignment about feature extraction and classification, we will now move into additional sketch-specific operations. Over the next two assignments, we will cover stroke segmentation (corner finding) and a couple of simple recognition algorithms. Homework 2 will focus on segmentation.
Instructions
Languages and Data
While there is no "required" language for this assignment, it is strongly recommended that you use Javascript. The primary reason is ready access to the data. As we move from having a couple hundred files of small, single-stroke sketches into more complicated tasks, we will be dealing with thousands of sketches, with multiple strokes and shapes that are of substantial size. Rather than downloading large datasets to your local computer, all data for this homework is provided via the Sketch Recognition Library database API (srlib_db), which was an optional data source in the first homework.
The data handlers for srlib_db are available in Javascript via srlib_js, which is included in a limited form in the Starter code available on the class drive under "Homework 2". The documentation for srlib_js is also included; it is a JSDoc directory and so should be downloaded and read through a web browser.
The specification of SketchML::JSON, which is the format of all sketches on srlib_db, is also available in the homework's folder. If you wish to use another language, that will be a useful reference, but any language that handles JSON-like objects natively will be easy to adapt. Furthermore, if you wish to use another language, you should make an HTTP GET request to http://srl-prod1.cs.tamu.edu:7750/getSketches?domain=MechanixCleaned&interpretation=force to retrieve the data. That particular request simply grabs the first 50 sketches, and the Starter code grabs 200 between 4000 and 4200. None of these numbers really matter as the main goal is to collect some pool of data for using with your segmentation algorithm.
Segmentation
The goal of the assignment is that, given a set of raw strokes, you can segment them successfully into a set of segmented substrokes. You may implement any corner finding / segmentation algorithm you would like. This can be an algorithm from class, a paper, or one of your own creation. A few points will be awarded based on creativity of your algorithm.
Try to make an algorithm which performs fairly well on the data set. All of the sketches in srlib_db for this domain (MechanixCleaned) will feature a set of raw strokes and segmented substrokes. These are provided for comparison of your algorithm. There are thousands of sketches, so you will not be able to make use of the provided substrokes to hardcode a solution. Furthermore, some of the sketches are imperfect, with the occasional dropped stroke and mis-identified substroke. They were generated by a sketch recognition software tool -- Mechanix in this case. As such, you should try to make the best segmentation algorithm you can, knowing that some disagreements will exist between your algorithm and the original dataset.
Finally, Mechanix is designed to recognize trusses, so it segments strokes into substrokes at points of nodes on trusses. You may choose to ignore this form of segmentation for the assignment if you wish to focus on corner finding. It will not impact you greatly on this homework; however, as the subsequent homework will be using the same data to implement a recognizer for arrows and trusses, you may benefit from some additional work in finding truss nodes as corners in this homework.
More details will be shared regarding evaluation metrics soon. For now, the focus should be on an algorithm which generates substrokes and adds them to a sketch object when only working from the raw stroke data.
Starter Code
As with Homework 1, there is provided Starter code in the directory for Homework 2. This file already handles loading data and converting it into the appropriate format. It also visualizes the original sketch data, prefixed "old", and your sketch data, prefixed "new", according to either the strokes or substrokes. Note that Mechanix sketches may be large and can get cutoff on the canvas.
Due Date
Oct. 16, Sunday @ Midnight (extended from Oct. 12)
25% deducted per day late
Following on our previous assignment about feature extraction and classification, we will now move into additional sketch-specific operations. Over the next two assignments, we will cover stroke segmentation (corner finding) and a couple of simple recognition algorithms. Homework 2 will focus on segmentation.
Instructions
Languages and Data
While there is no "required" language for this assignment, it is strongly recommended that you use Javascript. The primary reason is ready access to the data. As we move from having a couple hundred files of small, single-stroke sketches into more complicated tasks, we will be dealing with thousands of sketches, with multiple strokes and shapes that are of substantial size. Rather than downloading large datasets to your local computer, all data for this homework is provided via the Sketch Recognition Library database API (srlib_db), which was an optional data source in the first homework.
The data handlers for srlib_db are available in Javascript via srlib_js, which is included in a limited form in the Starter code available on the class drive under "Homework 2". The documentation for srlib_js is also included; it is a JSDoc directory and so should be downloaded and read through a web browser.
The specification of SketchML::JSON, which is the format of all sketches on srlib_db, is also available in the homework's folder. If you wish to use another language, that will be a useful reference, but any language that handles JSON-like objects natively will be easy to adapt. Furthermore, if you wish to use another language, you should make an HTTP GET request to http://srl-prod1.cs.tamu.edu:7750/getSketches?domain=MechanixCleaned&interpretation=force to retrieve the data. That particular request simply grabs the first 50 sketches, and the Starter code grabs 200 between 4000 and 4200. None of these numbers really matter as the main goal is to collect some pool of data for using with your segmentation algorithm.
Segmentation
The goal of the assignment is that, given a set of raw strokes, you can segment them successfully into a set of segmented substrokes. You may implement any corner finding / segmentation algorithm you would like. This can be an algorithm from class, a paper, or one of your own creation. A few points will be awarded based on creativity of your algorithm.
Try to make an algorithm which performs fairly well on the data set. All of the sketches in srlib_db for this domain (MechanixCleaned) will feature a set of raw strokes and segmented substrokes. These are provided for comparison of your algorithm. There are thousands of sketches, so you will not be able to make use of the provided substrokes to hardcode a solution. Furthermore, some of the sketches are imperfect, with the occasional dropped stroke and mis-identified substroke. They were generated by a sketch recognition software tool -- Mechanix in this case. As such, you should try to make the best segmentation algorithm you can, knowing that some disagreements will exist between your algorithm and the original dataset.
Finally, Mechanix is designed to recognize trusses, so it segments strokes into substrokes at points of nodes on trusses. You may choose to ignore this form of segmentation for the assignment if you wish to focus on corner finding. It will not impact you greatly on this homework; however, as the subsequent homework will be using the same data to implement a recognizer for arrows and trusses, you may benefit from some additional work in finding truss nodes as corners in this homework.
More details will be shared regarding evaluation metrics soon. For now, the focus should be on an algorithm which generates substrokes and adds them to a sketch object when only working from the raw stroke data.
Starter Code
As with Homework 1, there is provided Starter code in the directory for Homework 2. This file already handles loading data and converting it into the appropriate format. It also visualizes the original sketch data, prefixed "old", and your sketch data, prefixed "new", according to either the strokes or substrokes. Note that Mechanix sketches may be large and can get cutoff on the canvas.
Obtaining Credit
Again, the goal of this assignment is that you write a corner finding / segmentation algorithm. You will need to submit all of your source files to the grader. Also, include a small report describing what algorithm you implemented, the intuition of how it works, and the most difficult problems you encountered. If you run the metrics code, include those numbers as well.
Please ZIP all your files together into a single file submission titled "HW2_<last name>_<first initial>.zip". Since the university may block ZIP files, it is recommended that you upload your file to Google Drive and share the link via email.
More details will follow regarding the evaluation metrics. Remember that the Mechanix data is imperfect, which will be accounted for during the grading process; however, srlib_db has a large sketch library against which your work may be checked, so you should still strive to write an algorithm which performs well on the supplied data.
Although this assignment seems large because of the size of the data repository, it really only consists of a single algorithm, likely meaning less code than the first homework. Thus, you will have roughly a week and a half to complete the assignment.
Please ZIP all your files together into a single file submission titled "HW2_<last name>_<first initial>.zip". Since the university may block ZIP files, it is recommended that you upload your file to Google Drive and share the link via email.
More details will follow regarding the evaluation metrics. Remember that the Mechanix data is imperfect, which will be accounted for during the grading process; however, srlib_db has a large sketch library against which your work may be checked, so you should still strive to write an algorithm which performs well on the supplied data.
Although this assignment seems large because of the size of the data repository, it really only consists of a single algorithm, likely meaning less code than the first homework. Thus, you will have roughly a week and a half to complete the assignment.
Due Date
Oct. 16, Sunday @ Midnight (extended from Oct. 12)
25% deducted per day late
Friday, September 30, 2016
Reading 8 - ShortStraw
Paper
Wolin, A., Eoff, B., & Hammond, T. (2008, June). ShortStraw: A Simple and Effective Corner Finder for Polylines. In SBM (pp. 33-40).
Notes
Continuing on corner finding, we will now look at a very simple segmentation algorithm -- ShortStraw
Wolin, A., Eoff, B., & Hammond, T. (2008, June). ShortStraw: A Simple and Effective Corner Finder for Polylines. In SBM (pp. 33-40).
Notes
Continuing on corner finding, we will now look at a very simple segmentation algorithm -- ShortStraw
Wednesday, September 28, 2016
Reading 7 - Sezgin and Stahovich
Paper
Sezgin, Tevfik Metin, Thomas Stahovich, and Randall Davis. "Sketch based interfaces: early processing for sketch understanding." ACM SIGGRAPH 2006 Courses. ACM, 2006.
Notes
Up to this point, we've been concerned with understanding and building features of strokes and using these features to describe and classify gestures. With that background on machine learning and the familiarity gained with working on sketch data, we are now moving into more sketch-specific problems. To begin with, we will look at corner detection for a few readings. One of the more important original works in corner detection also helps to communicate the intuition behind the features that are often used, so we will be starting with the Sezgin/Stahovich paper shared in the class drive.
Sezgin, Tevfik Metin, Thomas Stahovich, and Randall Davis. "Sketch based interfaces: early processing for sketch understanding." ACM SIGGRAPH 2006 Courses. ACM, 2006.
Notes
Up to this point, we've been concerned with understanding and building features of strokes and using these features to describe and classify gestures. With that background on machine learning and the familiarity gained with working on sketch data, we are now moving into more sketch-specific problems. To begin with, we will look at corner detection for a few readings. One of the more important original works in corner detection also helps to communicate the intuition behind the features that are often used, so we will be starting with the Sezgin/Stahovich paper shared in the class drive.
Wednesday, September 21, 2016
Reading 6 - Geometry Overview
Paper
Hammond, T. "Fundamentals of Geometry". Draft
Notes
In the shared folder for Readings, you can access the draft version of Dr. Hammond's paper on basic geometry. This paper provides some background information on dealing with geometries, vector spaces, and matrices. Not only is the knowledge applicable to a number of classification methods, such as our current linear classification discussion, but it is also a good review of trigonometry and functions that we often deal with in feature extraction. As we move on to other methods of recognition, this intuition will be useful.
Hammond, T. "Fundamentals of Geometry". Draft
Notes
In the shared folder for Readings, you can access the draft version of Dr. Hammond's paper on basic geometry. This paper provides some background information on dealing with geometries, vector spaces, and matrices. Not only is the knowledge applicable to a number of classification methods, such as our current linear classification discussion, but it is also a good review of trigonometry and functions that we often deal with in feature extraction. As we move on to other methods of recognition, this intuition will be useful.
Sunday, September 18, 2016
Reading 5 - Metrics Overview
Paper
Hammond, T. "Evalutation Methods and Metrics". Draft
Notes
In the shared folder for Readings, you can access the draft version of Dr. Hammond's paper on evaluation metrics. This paper is a general overview of some common methods used in evaluation and accuracy reporting for machine learning problems. In this class, we'll be dealing with features and classifiers in lectures, homeworks, and more, so having a good understanding of the basics of evaluation will be very helpful.
Hammond, T. "Evalutation Methods and Metrics". Draft
Notes
In the shared folder for Readings, you can access the draft version of Dr. Hammond's paper on evaluation metrics. This paper is a general overview of some common methods used in evaluation and accuracy reporting for machine learning problems. In this class, we'll be dealing with features and classifiers in lectures, homeworks, and more, so having a good understanding of the basics of evaluation will be very helpful.
Tuesday, September 13, 2016
Homework 1 - Features and Classification
Overview
This marks the first programming-based homework assignment of the course. The intention behind this assignment is to prepare you for the class project and give some practical experience using the material we've been discussing in lecture. You will need to implement feature transformations and perform some classification on those features for this homework. It may be considered across two parts:
1. Rubine Features
2. Weka Classification
Instructions
There is no required programming language for this homework. The only requirements are that you implement Rubine and use Weka. To measure your performance on these tasks, you will need to follow some data format guidelines -- use the data provided and make sure your feature extractor outputs or can be made to easily output a CSV file. These details will be discussed shortly, but keep them in mind when choosing how you wish to begin the homework.
Also, a "Homework 1" directory has been added inside the shared class Google Drive. It contains all the downloadable materials for this assignment.
1. Rubine Features
a. Data
First, you'll need the data. There are two data sets. One is the small sample set which we have seen in quizzes and in discussion. The sample CSV output is also available for this data set so that you may check your feature extractor before applying it to the second data set. The second data set is a collection of alphabet letters. There are 20 samples for each letter.
Data is available to you in three ways.
i. TXT Files
The TXT version of the data is the most rudimentary means of storing a sketch available. These files list only the points, with each line containing x, y, and t for a single point. Reading the raw data from these files should be relatively simple, but there's no inherent structure about the sketch that is saved.
ii. JSON files
The JSON version of the data is saved in the SketchML::JSON format, developed by the Sketch Recognition Lab and based on MIT's original SketchML format on the XML platform. This format is still fairly lightweight compared to XML, although not as compact as the TXT format. It provides structure to the data, giving a collection of points, strokes, and more to the sketch object. JSON is very easy to work with in many modern languages, but you may wish to reference the SketchML::JSON specification document if you decide to parse the JSON yourself. It is saved alongside the data in the same folder.
iii. Sketch Recognition Library API
The Sketch Recognition Library (srlib) is a collection of sketches from different domains that have been gathered into a single format (SketchML::JSON) and made available through a RESTful API. All the data used for this assignment may be accessed from the srlib API, but it is not available on the Google Drive. It is live online from http://srl-prod1.cs.tamu.edu:7750/. You must be on campus or on the VPN to access it. That link will direct you to the documentation. All you need to get started is that the "sample" data set is available with the domain "rubine" and the "letters" data set is available with the domain "letters". An example is included in the starter code discussed below.
b. Feature Extraction
Regardless of how you choose to get the data, you must implement all 13 of Rubine's features. The sample data set is provided to assist you in debugging, while the larger data set of letters will be used in the next stage with Weka.
To provide further assistance with this step, starter code has been included in the shared folder. The starter code does not implement any of the feature transforms. It is actually intended to be a viewer for you as another means of debugging. To use it as a viewer, download all the files in the starter folder and open "index.html" in your browser.
Because it uses the srlib database and includes a special build of the srlib Javascript toolkit (data management functions only), it is essentially the same code you would be writing to access the data from srlib in Javascript on your own. For that reason, I added a single line, a callback function to an empty "getFeatures()" function where you may implement your feature extractor if you wish to work with the starter code. Again, you may use any language you want, so there's no requirement to use the starter code. Even if you do wish to work in Javascript, you may want to look at the data in its raw TXT or JSON form to see how it looks. But because this homework is concerned with feature extraction and classification, not data handling and plotting, the viewer and Javascript tools are available as a resource.
c. Output
The reason the language doesn't matter is because the output will be important. Your program should generate a CSV file, or log console output which can be readily saved as CSV, where each row represents a sketch. Thus, for the sample data set, you will have 8 rows of features. The letters data set will have 20*26 rows.
Each row should contain the sketch's class/interpretation followed by the 13 Rubine feature values in order of F1 through F13. For the sample data set, the class can just be the name or ID; it doesn't really matter. For the letters data set, you should save the letter as the class. The letter is saved in the SketchML::JSON data under the top-level shape's "interpretation" field.
The file "sample.csv" provides the Rubine feature values for the sample data set to assist in your evaluation. You will need to generate "letters.csv" using your feature extractor.
2. Weka Classification
The second half of the assignment will not require any additional programming. For this part, you'll be using Weka to build some classifiers with the features you extracted in the previous part. Weka can import CSV directly, which is one of the primary reasons that your feature extractor should support saving CSV features... the other being ease of grading.
Once you have a "letters.csv" which has the class label and set of 13 features for all 520 sketches, import the data into the Weka Explorer. From Explorer mode, you can test out many different functions in Weka, including classification, dimensionality reduction, and visualization.
Try at least 5 different classifiers on the data. Think about mixing k-fold cross-validation and other data splitting methods. You should report the classifiers and settings you chose along with the results in your report to be submitted with the code and CSV files.
I've tried to include all the materials you'll need either online or in the shared class folder.
At the end of both parts of the homework, you'll have gained some familiarity with gesture-based sketch features and classification methods through Weka. Later, we'll be investigating the programming-based recognition a bit more, so you will probably have the chance to implement classifiers, segmenters, and other sketch algorithms in upcoming assignments.
Due Date
Sep. 26, Monday @ Midnight
25% deducted per day late
This marks the first programming-based homework assignment of the course. The intention behind this assignment is to prepare you for the class project and give some practical experience using the material we've been discussing in lecture. You will need to implement feature transformations and perform some classification on those features for this homework. It may be considered across two parts:
1. Rubine Features
2. Weka Classification
Instructions
There is no required programming language for this homework. The only requirements are that you implement Rubine and use Weka. To measure your performance on these tasks, you will need to follow some data format guidelines -- use the data provided and make sure your feature extractor outputs or can be made to easily output a CSV file. These details will be discussed shortly, but keep them in mind when choosing how you wish to begin the homework.
Also, a "Homework 1" directory has been added inside the shared class Google Drive. It contains all the downloadable materials for this assignment.
1. Rubine Features
a. Data
First, you'll need the data. There are two data sets. One is the small sample set which we have seen in quizzes and in discussion. The sample CSV output is also available for this data set so that you may check your feature extractor before applying it to the second data set. The second data set is a collection of alphabet letters. There are 20 samples for each letter.
Data is available to you in three ways.
i. TXT Files
The TXT version of the data is the most rudimentary means of storing a sketch available. These files list only the points, with each line containing x, y, and t for a single point. Reading the raw data from these files should be relatively simple, but there's no inherent structure about the sketch that is saved.
ii. JSON files
The JSON version of the data is saved in the SketchML::JSON format, developed by the Sketch Recognition Lab and based on MIT's original SketchML format on the XML platform. This format is still fairly lightweight compared to XML, although not as compact as the TXT format. It provides structure to the data, giving a collection of points, strokes, and more to the sketch object. JSON is very easy to work with in many modern languages, but you may wish to reference the SketchML::JSON specification document if you decide to parse the JSON yourself. It is saved alongside the data in the same folder.
iii. Sketch Recognition Library API
The Sketch Recognition Library (srlib) is a collection of sketches from different domains that have been gathered into a single format (SketchML::JSON) and made available through a RESTful API. All the data used for this assignment may be accessed from the srlib API, but it is not available on the Google Drive. It is live online from http://srl-prod1.cs.tamu.edu:7750/. You must be on campus or on the VPN to access it. That link will direct you to the documentation. All you need to get started is that the "sample" data set is available with the domain "rubine" and the "letters" data set is available with the domain "letters". An example is included in the starter code discussed below.
b. Feature Extraction
Regardless of how you choose to get the data, you must implement all 13 of Rubine's features. The sample data set is provided to assist you in debugging, while the larger data set of letters will be used in the next stage with Weka.
To provide further assistance with this step, starter code has been included in the shared folder. The starter code does not implement any of the feature transforms. It is actually intended to be a viewer for you as another means of debugging. To use it as a viewer, download all the files in the starter folder and open "index.html" in your browser.
Because it uses the srlib database and includes a special build of the srlib Javascript toolkit (data management functions only), it is essentially the same code you would be writing to access the data from srlib in Javascript on your own. For that reason, I added a single line, a callback function to an empty "getFeatures()" function where you may implement your feature extractor if you wish to work with the starter code. Again, you may use any language you want, so there's no requirement to use the starter code. Even if you do wish to work in Javascript, you may want to look at the data in its raw TXT or JSON form to see how it looks. But because this homework is concerned with feature extraction and classification, not data handling and plotting, the viewer and Javascript tools are available as a resource.
c. Output
The reason the language doesn't matter is because the output will be important. Your program should generate a CSV file, or log console output which can be readily saved as CSV, where each row represents a sketch. Thus, for the sample data set, you will have 8 rows of features. The letters data set will have 20*26 rows.
Each row should contain the sketch's class/interpretation followed by the 13 Rubine feature values in order of F1 through F13. For the sample data set, the class can just be the name or ID; it doesn't really matter. For the letters data set, you should save the letter as the class. The letter is saved in the SketchML::JSON data under the top-level shape's "interpretation" field.
The file "sample.csv" provides the Rubine feature values for the sample data set to assist in your evaluation. You will need to generate "letters.csv" using your feature extractor.
2. Weka Classification
The second half of the assignment will not require any additional programming. For this part, you'll be using Weka to build some classifiers with the features you extracted in the previous part. Weka can import CSV directly, which is one of the primary reasons that your feature extractor should support saving CSV features... the other being ease of grading.
Once you have a "letters.csv" which has the class label and set of 13 features for all 520 sketches, import the data into the Weka Explorer. From Explorer mode, you can test out many different functions in Weka, including classification, dimensionality reduction, and visualization.
Try at least 5 different classifiers on the data. Think about mixing k-fold cross-validation and other data splitting methods. You should report the classifiers and settings you chose along with the results in your report to be submitted with the code and CSV files.
I've tried to include all the materials you'll need either online or in the shared class folder.
At the end of both parts of the homework, you'll have gained some familiarity with gesture-based sketch features and classification methods through Weka. Later, we'll be investigating the programming-based recognition a bit more, so you will probably have the chance to implement classifiers, segmenters, and other sketch algorithms in upcoming assignments.
Obtaining Credit
You will need to email the grader all of your files.
For simplicity, place all your files inside a single folder named "HW1_<last name>_<first name>" that will be compressed and submitted as a ZIP. You should include the following files:
+ If you decided to download a data set (JSON or TXT), include these files in a "data" directory.
+ Include the source code which reads the data and generates the features in a "source" directory. This can be a single file or multiple files, even a combination of scripts. If your source is more than a single file, please add a small README that tells which one to run.
+ Include your CSV files for both the sample and letters data sets in a "results" directory.
+ Include the output of the weka console after testing each of your 5 different classifiers and configurations in the same "results" directory with the CSV files. This can just be a TXT file that you make by copying-and-pasting from the weka window.
+ Include your report which (briefly) discusses the options you tried out in Weka and reports your findings in the top level. You should have at least a small discussion of your findings. Were you pleased with the results? Did the exercise help you think of different features which you feel would be more important? Any general impressions you had during either part of the assignment could be excellent material for a discussion. (e.g. "First, I tried a Random Forest with 10-fold cross validation and obtained an F-measure of 86.4%. Next, I wanted to see how a neural network would perform, so I ran a multilayer perceptron with...")
To recap, a submission might look like this:
HW1_Polsley_Seth/
|-- data/
|---- sample-json/ (contains all the sample json files)
|---- letters-json/ (contains all the letter json files)
|-- source/
|---- rubine.py
|-- results/
|---- sample.csv
|---- letters.csv
|---- wekalog.txt
|-- report.txt
This layout isn't an exact science. I mainly want to make sure you include everything to demonstrate that you completed each part, and the structure is intended to make it easier for you to show that. If you used the Sketch Recognition Library starter code, you can have many fewer files. If you wish to consolidate the weka log into your report, that is also fine. So another submission may be:
HW1_Polsley_Seth/
|-- index.html
|-- require.js
|-- srlib.js
|-- sample.csv
|-- letters.csv
|-- report.pdf
This is also fine. I mostly just need your code, the code output (csv files), weka output (weka log), and a short write-up (discussion/report). Include these all in some obvious manner, and it's ok.
Again, please ZIP all your files together into a single file submission titled "HW1_<last name>_<first initial>.zip"
As always, contact me if you have any questions.
For simplicity, place all your files inside a single folder named "HW1_<last name>_<first name>" that will be compressed and submitted as a ZIP. You should include the following files:
+ If you decided to download a data set (JSON or TXT), include these files in a "data" directory.
+ Include the source code which reads the data and generates the features in a "source" directory. This can be a single file or multiple files, even a combination of scripts. If your source is more than a single file, please add a small README that tells which one to run.
+ Include your CSV files for both the sample and letters data sets in a "results" directory.
+ Include the output of the weka console after testing each of your 5 different classifiers and configurations in the same "results" directory with the CSV files. This can just be a TXT file that you make by copying-and-pasting from the weka window.
+ Include your report which (briefly) discusses the options you tried out in Weka and reports your findings in the top level. You should have at least a small discussion of your findings. Were you pleased with the results? Did the exercise help you think of different features which you feel would be more important? Any general impressions you had during either part of the assignment could be excellent material for a discussion. (e.g. "First, I tried a Random Forest with 10-fold cross validation and obtained an F-measure of 86.4%. Next, I wanted to see how a neural network would perform, so I ran a multilayer perceptron with...")
To recap, a submission might look like this:
HW1_Polsley_Seth/
|-- data/
|---- sample-json/ (contains all the sample json files)
|---- letters-json/ (contains all the letter json files)
|-- source/
|---- rubine.py
|-- results/
|---- sample.csv
|---- letters.csv
|---- wekalog.txt
|-- report.txt
This layout isn't an exact science. I mainly want to make sure you include everything to demonstrate that you completed each part, and the structure is intended to make it easier for you to show that. If you used the Sketch Recognition Library starter code, you can have many fewer files. If you wish to consolidate the weka log into your report, that is also fine. So another submission may be:
HW1_Polsley_Seth/
|-- index.html
|-- require.js
|-- srlib.js
|-- sample.csv
|-- letters.csv
|-- report.pdf
This is also fine. I mostly just need your code, the code output (csv files), weka output (weka log), and a short write-up (discussion/report). Include these all in some obvious manner, and it's ok.
Again, please ZIP all your files together into a single file submission titled "HW1_<last name>_<first initial>.zip"
As always, contact me if you have any questions.
Due Date
Sep. 26, Monday @ Midnight
25% deducted per day late
Monday, September 12, 2016
Reading 4 - Gesture Overview
Paper
Hammond, T. "Introduction to Gesture Recognition". Draft
Notes
In the shared folder for Readings, you can access the draft version of Dr. Hammond's paper on gesture recognition. It is an overview of all the previous gesture work we've discussed and provides many practical explanations and examples to help cement these concepts before we move on into classification techniques and other types of recognizers.
Hammond, T. "Introduction to Gesture Recognition". Draft
Notes
In the shared folder for Readings, you can access the draft version of Dr. Hammond's paper on gesture recognition. It is an overview of all the previous gesture work we've discussed and provides many practical explanations and examples to help cement these concepts before we move on into classification techniques and other types of recognizers.
Sunday, September 11, 2016
Reading 3 - Long
Paper
Long Jr, A. Chris, et al. "Visual similarity of pen gestures." Proceedings of the SIGCHI conference on Human Factors in Computing Systems. ACM, 2000.
Notes
Long's analysis of gesture features builds further on Rubine's original work in the field. The most important section of this paper is the discussion and results of the set of experiments measuring the most useful features of gesture similarity. As a small reminder, while the Monday and Wednesday readings should have summary blog posts completed by this weekend, this reading and other Friday readings are not due until the next weekend. The Reading Policy post has more details.
Long Jr, A. Chris, et al. "Visual similarity of pen gestures." Proceedings of the SIGCHI conference on Human Factors in Computing Systems. ACM, 2000.
Notes
Long's analysis of gesture features builds further on Rubine's original work in the field. The most important section of this paper is the discussion and results of the set of experiments measuring the most useful features of gesture similarity. As a small reminder, while the Monday and Wednesday readings should have summary blog posts completed by this weekend, this reading and other Friday readings are not due until the next weekend. The Reading Policy post has more details.
Wednesday, September 7, 2016
Assignment 6 - Project Exploration
Overview
Following up on Assignment 5, you will now do some very tentative exploration into the project area which is interesting to you. This should be a small assignment; the intention is to start helping you build a little background experience in the domain and reshape your ideas based on the prior work.
Instructions
Go to Google Scholar and input some general search terms related to your project idea(s). Based on just the titles and abstracts, find 10 prior works which appear to be relevant to your own project goals. You do not have to read these papers, simply find 10 that appear to be related. You should then create a blog post with the citations of all 10 papers. Hint: Clicking "Cite" under a result in Google Scholar will give you the citation information; MLA is sufficient for listing on your blog.
Due Date
Sep. 12, Monday @ 11:30 AM
25% deducted per day late
Following up on Assignment 5, you will now do some very tentative exploration into the project area which is interesting to you. This should be a small assignment; the intention is to start helping you build a little background experience in the domain and reshape your ideas based on the prior work.
Instructions
Go to Google Scholar and input some general search terms related to your project idea(s). Based on just the titles and abstracts, find 10 prior works which appear to be relevant to your own project goals. You do not have to read these papers, simply find 10 that appear to be related. You should then create a blog post with the citations of all 10 papers. Hint: Clicking "Cite" under a result in Google Scholar will give you the citation information; MLA is sufficient for listing on your blog.
Obtaining Credit
You should have a blog post corresponding to Assignment 6 posted on your blog by the due date. Again, this is simply a list of 10 paper citations related to your project idea(s).
Due Date
Sep. 12, Monday @ 11:30 AM
25% deducted per day late
Reading Policy
Overview
As promised earlier, I wanted to provide a little more detail about the readings in this course. I've given more information below in regards to the reading assignment schedule, in-class deliverables like quizzes, and out-of-class deliverables like blog posts.
Readings Assignment Schedule
Readings will be regularly assigned in class M, W, and F. There won't necessarily be a reading every day, but they'll roughly correspond to this schedule. They are not meant to be an onerous burden; rather, readings are given to provide you some background and supplemental material for the content of the class.
In-Class Deliverables
In-class discussions and quiz questions may draw on material from the readings. Generally, you should review a reading before the next class from which it was assigned. Thus, a reading assigned Monday might be discussed on Wednesday. A reading given on Friday would be fair game for a quiz question on Monday. I say to "review" readings because you are encouraged to go through readings at whatever pace is comfortable for you, so that you understand the concept and key points. You do not have to do a detailed, rigorous review.
Out-of-Class Deliverables
Outside of coverage of readings in discussion and quizzes, the primary graded component to a reading will be a blog posts. Using the blog you created in Assignment 2, you'll be posting a little bit about each reading.
Blog Post Contents
You should post the name and reference of the paper concerned, a short summary, and any thoughts you had about the paper. These posts are primarily for your benefit to use as reference later when working on your project paper or reviewing readings for quizzes. They do not need to be long; just communicate what you took away from the paper.
Blog Grading Timeline
Rather than check everything at the end of the class, I think it will be easier for everybody to do regular checks. This will ensure that you are keeping up in the course without my constantly checking everyone's blogs.
Su Mo Tu We Th Fr Sa
1 2 3
4 5 6 7 8 9 10
11 12 13 14 15 16 17
18 19 20 21 22 23 24
25 26 27 28 29 30
As promised earlier, I wanted to provide a little more detail about the readings in this course. I've given more information below in regards to the reading assignment schedule, in-class deliverables like quizzes, and out-of-class deliverables like blog posts.
Readings Assignment Schedule
Readings will be regularly assigned in class M, W, and F. There won't necessarily be a reading every day, but they'll roughly correspond to this schedule. They are not meant to be an onerous burden; rather, readings are given to provide you some background and supplemental material for the content of the class.
In-Class Deliverables
In-class discussions and quiz questions may draw on material from the readings. Generally, you should review a reading before the next class from which it was assigned. Thus, a reading assigned Monday might be discussed on Wednesday. A reading given on Friday would be fair game for a quiz question on Monday. I say to "review" readings because you are encouraged to go through readings at whatever pace is comfortable for you, so that you understand the concept and key points. You do not have to do a detailed, rigorous review.
Out-of-Class Deliverables
Outside of coverage of readings in discussion and quizzes, the primary graded component to a reading will be a blog posts. Using the blog you created in Assignment 2, you'll be posting a little bit about each reading.
Blog Post Contents
You should post the name and reference of the paper concerned, a short summary, and any thoughts you had about the paper. These posts are primarily for your benefit to use as reference later when working on your project paper or reviewing readings for quizzes. They do not need to be long; just communicate what you took away from the paper.
Blog Grading Timeline
Rather than check everything at the end of the class, I think it will be easier for everybody to do regular checks. This will ensure that you are keeping up in the course without my constantly checking everyone's blogs.
To that effect, I plan to be looking at everyone's blogs once a week on Sunday afternoons. While in-class deliverables may occur as early as the next class, you will always have at least half a week for out-of-class deliverables. Thus, the blog posts for readings assigned on Mondays and Wednesdays will be due by that upcoming Sunday. The blog posts for readings assigned on Friday will be due the next Sunday. Consider the following example:
Su Mo Tu We Th Fr Sa
1 2 3
4 5 6 7 8 9 10
11 12 13 14 15 16 17
18 19 20 21 22 23 24
25 26 27 28 29 30
The calendar above shows the month of September and sample reading assignments. All the red readings should have a corresponding blog post by the bold-red Sunday. Likewise, all the blue readings should have a corresponding blog post by the bold-blue Sunday, and so on. This gives you a little over a week to finish Friday readings, slightly under a week to finish Monday readings, and half a week to finish Wednesday readings. A concrete example: Readings 1 and 2 will need to be blogged by this coming Sunday, Sept. 11. If there is a Reading 3 on Friday, it would not be due until Sunday, Sept. 18.
Note that the time I'll be checking on Sunday is intentionally left vague. This is because I really intend for everything to be posted by the end of Saturday, but I won't be checking that night. You can update on Sunday afternoon, but there's a possibility I'll have already checked your blog, so try to be a little earlier rather than later. There won't be any late submissions for readings, but since there are likely to be a lot of readings, missing a few will not have a very negative impact.
Conclusions
Note that the time I'll be checking on Sunday is intentionally left vague. This is because I really intend for everything to be posted by the end of Saturday, but I won't be checking that night. You can update on Sunday afternoon, but there's a possibility I'll have already checked your blog, so try to be a little earlier rather than later. There won't be any late submissions for readings, but since there are likely to be a lot of readings, missing a few will not have a very negative impact.
Conclusions
The key takeaways from this post:
- Readings will be given on class days
- They may be covered in discussion or quizzes as early as the next class, so a small review by then is encouraged
- The blog posts, which are really just your summaries of the readings, will be due the upcoming Sunday, except Friday readings will be due the next Sunday
- The grading time on Sunday is intentionally-ambiguous so that you may aim to have everything done by Saturday
- There is no late policy for readings, but don't worry about a missing a few here or there; a few will be dropped at the end as means of grading leniency in favor of late submissions
Email me if you have any questions or concerns regarding this policy.
Reading 2 - Rubine
Paper
Rubine, Dean. Specifying gestures by example. Vol. 25. No. 4. ACM, 1991.
Notes
Here we begin to study the origins of modern sketch recognition from an algorithmic perspective. The most important section to review from this work is part 4, which covers Rubine's features. Rubine's features partially form the basis of many gesture-based recognizers today. At the very least, familiarity with these sorts of feature constructs will help you gain an intuition for the type of information we can capture and use about a sketch.
Rubine, Dean. Specifying gestures by example. Vol. 25. No. 4. ACM, 1991.
Notes
Here we begin to study the origins of modern sketch recognition from an algorithmic perspective. The most important section to review from this work is part 4, which covers Rubine's features. Rubine's features partially form the basis of many gesture-based recognizers today. At the very least, familiarity with these sorts of feature constructs will help you gain an intuition for the type of information we can capture and use about a sketch.
Monday, September 5, 2016
Reading 1 - Dialectical Creativity
Paper
Hammond, Tracy. "Dialectical Creativity: Sketch-Negate-Create." Studying Visual and Spatial Reasoning for Design Creativity. Springer Netherlands, 2015. 91-108.
Notes
This is a good introductory reading in the field of general sketch recognition. It should help motivate upcoming content in the course and encourage project ideas.
You may access the paper from the Google drive folder "CSCE624 Class Files" available to all students in the class. If you did not receive access, let me know so you may be added to the class group.
Hammond, Tracy. "Dialectical Creativity: Sketch-Negate-Create." Studying Visual and Spatial Reasoning for Design Creativity. Springer Netherlands, 2015. 91-108.
Notes
This is a good introductory reading in the field of general sketch recognition. It should help motivate upcoming content in the course and encourage project ideas.
You may access the paper from the Google drive folder "CSCE624 Class Files" available to all students in the class. If you did not receive access, let me know so you may be added to the class group.
Assignment 5 - Project Ideas
Overview
Even though it's only the second week of class, it will be helpful to start thinking about what aspects of sketch recognition interest you and, more specifically, shaping these ideas into potential topics for your end-of-semester project. To further that goal, this assignment is that you post a paragraph about potential topic ideas to your blog.
Instructions
Post a paragraph on your blog regarding potential topic ideas for the class project. It does not have to be very refined yet. Think about your interests; why are you interested to learn sketch recognition? Can this be morphed into a project? Perhaps one of the ideas already presented in class is appealing to you, or your own research holds a sub-topic related to sketch recognition. Again, the purpose of this assignment is to encourage you to start thinking about the final project, so spend some time brainstorming, and write up your best idea(s).
Due Date
Sep. 7, Wednesday @ 11:30 AM
25% deducted per day late
It is a very simple exercise primarily for your own benefit, so everyone should be able to complete it by class on Wednesday.
Even though it's only the second week of class, it will be helpful to start thinking about what aspects of sketch recognition interest you and, more specifically, shaping these ideas into potential topics for your end-of-semester project. To further that goal, this assignment is that you post a paragraph about potential topic ideas to your blog.
Instructions
Post a paragraph on your blog regarding potential topic ideas for the class project. It does not have to be very refined yet. Think about your interests; why are you interested to learn sketch recognition? Can this be morphed into a project? Perhaps one of the ideas already presented in class is appealing to you, or your own research holds a sub-topic related to sketch recognition. Again, the purpose of this assignment is to encourage you to start thinking about the final project, so spend some time brainstorming, and write up your best idea(s).
Obtaining Credit
You should have a blog post corresponding to Assignment 5 posted on your blog by the due date.
Due Date
Sep. 7, Wednesday @ 11:30 AM
25% deducted per day late
It is a very simple exercise primarily for your own benefit, so everyone should be able to complete it by class on Wednesday.
Saturday, September 3, 2016
Assignment 4 - Persketchtivity Usage and Analysis
Overview
Following on the previous assignment in which you completed a tutorial in Mechanix, you will be using another live educational sketching tool: Persketchtivity. This software should be much easier to use because it is available online, has automatic lesson progression, and only consists of drawing simple shapes. After using Persketchtivity, you will be asked to once again write about your impressions in a list of "Do's and Don'ts of Sketch Recognition Systems, Part 2".
Instructions
First, you should complete the steps below to gain some experience using Persketchtivity.
Due Date
This assignment should be submitted in two parts. It should be completely finished by Monday Sep. 5, but the Persketchtivity exercises should be done by class on Monday Sep. 2.
Persketchtivity Exercises
Sep. 5, Monday @ 11:30 AM
Only excused late submissions (e.g. late enrollment)
Consider this as a sort of "checkpoint" so that we can ensure everyone has gained familiarity with Persketchtivity and address any problems that arise before the blog assignment is due that night.
"Do's and Don'ts of Sketch Recognition Systems, Part 2" Blog Post
Sep. 5, Monday @ Midnight
25% deducted per day late
This is when the second "Do's and Don'ts" list should be posted on your blog.
Following on the previous assignment in which you completed a tutorial in Mechanix, you will be using another live educational sketching tool: Persketchtivity. This software should be much easier to use because it is available online, has automatic lesson progression, and only consists of drawing simple shapes. After using Persketchtivity, you will be asked to once again write about your impressions in a list of "Do's and Don'ts of Sketch Recognition Systems, Part 2".
Instructions
First, you should complete the steps below to gain some experience using Persketchtivity.
- Go to http://persketchtivity.com/ to access the main Persketchtivity log in page.
- Return to the User ID spreadsheet that you used to log in to Mechanix. Your user id is the same for Persketchtivity. Once again, note that the password and user name are equal.
- Complete the available lessons. This consists of four different primitive shape lessons and a few 3D shapes and combos. Many of the lessons have sub modules, but all of the exercises are small and should not take much time to complete.
Next, you must write a short post on your blog about the "Do's and Don'ts of Sketch Recognition Systems, Part 2". Specifically, list at least 5 aspects of Persketchtivity which you liked as the "Do's" and list at least 5 aspects of Persketchtivity which you disliked as the "Don'ts". These aspects may refer to the usability of the system, design of the interface, or any other observation relevant to sketch recognition software in some way. You may present the lists as bullets or paragraphs, but there should be 10 distinct observations clearly contributed in the post.
Obtaining Credit
Your submissions will automatically be visible to us on the instructor side, so you do not need to submit any certificate or problem solutions to show that you completed the lessons. However, we need to know who is who, so you must use the user name provided in the spreadsheet. Remember the user name and passwords are the same.
To obtain credit for the "Do's and Don'ts of Sketch Recognition Systems, Part 2", ensure you have posted your 10 observations (5 do's and 5 don'ts) to your blog. This should be the same blog you provided a link to on the spreadsheet provided with Assignment 2.
Due Date
This assignment should be submitted in two parts. It should be completely finished by Monday Sep. 5, but the Persketchtivity exercises should be done by class on Monday Sep. 2.
Persketchtivity Exercises
Sep. 5, Monday @ 11:30 AM
Only excused late submissions (e.g. late enrollment)
Consider this as a sort of "checkpoint" so that we can ensure everyone has gained familiarity with Persketchtivity and address any problems that arise before the blog assignment is due that night.
"Do's and Don'ts of Sketch Recognition Systems, Part 2" Blog Post
Sep. 5, Monday @ Midnight
25% deducted per day late
This is when the second "Do's and Don'ts" list should be posted on your blog.
Tuesday, August 30, 2016
Assignment 3 - Mechanix Usage and Analysis
Overview
For the third course assignment, you are asked to do problems 1 through 11 of the TAMU Mechanix Tutorial and then write about the experience. Mechanix is one of the largest projects in the Sketch Recognition Lab, and it uses a combination of many recognition algorithms to automatically evaluate student truss drawings. Truss analysis is important in several areas of engineering, like civil engineering, and Mechanix aims to be a personal tutor as it teaches these concepts to students.
While most of you probably do not have a background in civil engineering, the Mechanix tutorial you have been assigned should be very easy to follow. Ultimately, the goal is that this assignment be a good learning experience while providing you with an introduction to the state of current sketch recognition software.
Instructions
First, you should complete the steps below to gain some experience using Mechanix.
Due Date
This assignment should be submitted in two parts. It should be completely finished by Monday Sep. 5, but the Mechanix tutorial itself should be done by class on Friday Sep. 2.
Mechanix Tutorial
Sep. 2, Friday @ 11:30 AM
Only excused late submission (e.g. late enrollment)
Consider this as a sort of "checkpoint" so that we can ensure everyone has gained familiarity with Mechanix and address any problems that arise before the blog assignment is due Monday.
"Do's and Don'ts of Sketch Recognition Systems" Blog Post
Sep. 5, Monday @ Midnight
25% deducted per day late
This is when the "Do's and Don'ts" list should be posted on your blog.
For the third course assignment, you are asked to do problems 1 through 11 of the TAMU Mechanix Tutorial and then write about the experience. Mechanix is one of the largest projects in the Sketch Recognition Lab, and it uses a combination of many recognition algorithms to automatically evaluate student truss drawings. Truss analysis is important in several areas of engineering, like civil engineering, and Mechanix aims to be a personal tutor as it teaches these concepts to students.
While most of you probably do not have a background in civil engineering, the Mechanix tutorial you have been assigned should be very easy to follow. Ultimately, the goal is that this assignment be a good learning experience while providing you with an introduction to the state of current sketch recognition software.
Instructions
First, you should complete the steps below to gain some experience using Mechanix.
- Go to http://faculty.cs.tamu.edu/hammond/mechanix.php and download Mechanix Student Version from the links on the lower right side (Direct Download Link). Note: If you're having trouble downloading, try connecting from campus or through the VPN.
- Ensure you have Java installed, either the JRE or the JDK; you should have version 7 or greater.
- Once you have Java installed and have downloaded the Mechanix application, double-click it to run the installer. This will download the latest version directly from our servers for you.
- Now, with Java and Mechanix ready to go, you should see a login screen to Mechanix. Login with the user name given to you from this spreadsheet. Note: The password and user name are the same.
- Select the TAMU Mechanix Tutorial; there should be only one.
- Step through problems 1 to 11, reading the instructions and submitting until you receive a "Correct" response each time. Mechanix provides a checklist and specific responses at each stage of the submission, so feel free to submit as often as possible until you get the correct solution.
- Problem 12 requires extra knowledge not well explained in the text. This part of the tutorial is more a demonstration of the types of problems which Mechanix can handle in different contexts. However, because it is only for demonstrative purposes and not well suited to this course, you do not need to complete problem 12. You may if you wish, but it will not be counted.
Next, based on your experience using Mechanix, you must write a short post on your blog about the "Do's and Don'ts of Sketch Recognition Systems". Specifically, list at least 5 aspects of Mechanix which you liked as the "Do's" and list at least 5 aspects of Mechanix which you disliked as the "Don'ts". These aspects may refer to the usability of the system, design of the interface, or any other observation relevant to sketch recognition software in some way. You may present the lists as bullets or paragraphs, but there should be 10 distinct observations clearly contributed in the post.
Obtaining Credit
Your submissions will automatically be visible to us on the instructor side, so you do not need to submit any certificate or problem solutions to show that you completed the tutorial. However, we need to know who is who, so you must use the user name provided in the spreadsheet. Remember the user name and passwords are the same.
To obtain credit for the "Do's and Don'ts of Sketch Recognition Systems", ensure you have posted your 10 observations (5 do's and 5 don'ts) to your blog. This should be the same blog you provided a link to on the spreadsheet provided with Assignment 2.
Due Date
This assignment should be submitted in two parts. It should be completely finished by Monday Sep. 5, but the Mechanix tutorial itself should be done by class on Friday Sep. 2.
Mechanix Tutorial
Sep. 2, Friday @ 11:30 AM
Only excused late submission (e.g. late enrollment)
Consider this as a sort of "checkpoint" so that we can ensure everyone has gained familiarity with Mechanix and address any problems that arise before the blog assignment is due Monday.
"Do's and Don'ts of Sketch Recognition Systems" Blog Post
Sep. 5, Monday @ Midnight
25% deducted per day late
This is when the "Do's and Don'ts" list should be posted on your blog.
Monday, August 29, 2016
Assignment 2 - Blog Creation
Overview
For the second assignment, you are asked to create a research blog where you will post your reviews and reference information for the papers you will read. This blog may also be used to submit other assignments throughout the semester. It will be shared with other members of the class, and you should leave comments open so that your classmates can make remarks on your posts.
Instructions
Go to Blogger and create a new blog. If you are already logged in with a Google Account (either your TAMU or personal), you should be taken to your Blogger dashboard. From there, click "New Blog" to start your research blog.
As mentioned before, make sure that comments are enabled, although they may be moderated if you wish. You may name the blog whatever you like.
Obtaining Credit
You are not required to create any posts or make any comments on other blogs at the moment. Just create it. In order to get credit for creating it, and also to share the link with your classmates so that they may find your blog, please access the Google Sheet below and provide a link to your blog next to your name.
Note that you must be signed in as your TAMU account in order to have edit permissions.
Student Blog Links
Due Date
Sep. 2, Friday @ Midnight
25% deducted per day late
For the second assignment, you are asked to create a research blog where you will post your reviews and reference information for the papers you will read. This blog may also be used to submit other assignments throughout the semester. It will be shared with other members of the class, and you should leave comments open so that your classmates can make remarks on your posts.
Instructions
Go to Blogger and create a new blog. If you are already logged in with a Google Account (either your TAMU or personal), you should be taken to your Blogger dashboard. From there, click "New Blog" to start your research blog.
As mentioned before, make sure that comments are enabled, although they may be moderated if you wish. You may name the blog whatever you like.
Obtaining Credit
You are not required to create any posts or make any comments on other blogs at the moment. Just create it. In order to get credit for creating it, and also to share the link with your classmates so that they may find your blog, please access the Google Sheet below and provide a link to your blog next to your name.
Note that you must be signed in as your TAMU account in order to have edit permissions.
Student Blog Links
Due Date
Sep. 2, Friday @ Midnight
25% deducted per day late
Assignment 1 - CITI Training
Overview
As the first assignment for CSCE 624, you are required to finish two training modules provided online by the CITI Program:
As the first assignment for CSCE 624, you are required to finish two training modules provided online by the CITI Program:
- Social and Behavioral Responsible Conduct of Research
- Group 2. Social and Behavioral Research Investigators and Key Personnel
By completing this training, you will be able to submit an IRB form that will allow you to collect data for your course project. It should also be helpful to your general research work outside of this class.
Instructions
To do the training, please follow the instructions in the link below:
Everything you need to know should be provided on that page, but the gist is that you should register with CITI Program under Texas A&M University. From there, select the modules you need to complete (RCR and Group 2) and go to your courses to begin. There will be several sections and quizzes after each section. More details will be provided on the CITI page, and the training should take a couple hours on average.
Obtaining Credit
Once you have completed both modules, download a PDF certificate by going to "Print Report". Send this certificate to the course grader, whose email address is given on the course syllabus linked from this post.
Due Date
Aug. 31, Wednesday @ Midnight
25% deducted per day late
Due Date
Aug. 31, Wednesday @ Midnight
25% deducted per day late
Note: Group 1 is biomedical training and is not required for this course. You may complete it if you wish, but it is much longer than the other two modules.
Course Syllabus
The syllabus is available on Google Docs from the link below:
CSCE 624 Syllabus
The content for the syllabus is largely static, so you don't need to worry about checking it often. Please read it at least once to be sure you understand the course structure and instructor expectations.
CSCE 624 Syllabus
The content for the syllabus is largely static, so you don't need to worry about checking it often. Please read it at least once to be sure you understand the course structure and instructor expectations.
Thursday, August 25, 2016
Welcome to Sketch Recognition!
Welcome to CSCE 624 for Fall 2016!
Sketch recognition is the field of automated recognition of hand-drawn diagrams, shapes, and other images by a computer. Because drawing provides a visual reference, it is an augmentative form of communication used all throughout daily life. It is pervasive in everything from education and business to healthcare and home. Like many human forms of communication, while we have mastered the art of drawing and recognizing images, computers still struggle with this ability. In this class, we will cover multiple sketch-related concepts, beginning with the origins and history of the field up to many more modern approaches.
Posts will follow with more details about the course and the first assignments, but for now, please remember:
Sketch recognition is the field of automated recognition of hand-drawn diagrams, shapes, and other images by a computer. Because drawing provides a visual reference, it is an augmentative form of communication used all throughout daily life. It is pervasive in everything from education and business to healthcare and home. Like many human forms of communication, while we have mastered the art of drawing and recognizing images, computers still struggle with this ability. In this class, we will cover multiple sketch-related concepts, beginning with the origins and history of the field up to many more modern approaches.
Posts will follow with more details about the course and the first assignments, but for now, please remember:
- This blog is the course web page. Be sure to check regularly as useful information will be posted here throughout the semester regarding assignments and course policies
We should have a lot of fun this semester!
Subscribe to:
Posts (Atom)