Project instruction:

Author(s): Dr. H and Gerard Pendleton Thurston the 4th

Note: You can delete this folder and remove it from the project website once you have read and understood the instructions. It shouldn’t be part of your final submission.

Audio instructions:

If you want, you can listen to the instructions:

Source: Text-to-speech conversion done with Amazon Polly on AWS

Note: These audio instructions should not be included in your final submission or repository, once you are done wiht them, please delete the files and remove them from the website.

Overview

Writing and communicating technical information in an understandable way is a critical and highly valued skill. The goal of this project is to create a data science story that explores and explains a particular topic or issue in a data-driven manner. Your portfolio will take the form of a narrative website that you will design. Each website must have a clear flow, be easy to navigate, load quickly, and tell an engaging, well-structured data science story. Additionally, your portfolio should be highly visual, featuring numerous visualizations throughout.

Framing: To structure your project, consider framing it in one of the following ways:

  • Academic Paper: Similar to a peer-reviewed paper, focusing on a data-driven problem.
  • Industry Project: You are hired as a data scientist to solve a company problem and present your findings.
  • Data Story: A narrative that uses data to tell a compelling story, similar to a data-driven news article from the New York Times.

In all three cases, you will need a final “report” for the stakeholder, ensuring transparency with your data, code, and processing methods.

We provide a website skeleton as a starting point for your project. Please do not modify the overall directory structure, though you are free to customize the look and feel. Each page in the skeleton includes specific instructions on what should be covered there.

OVERALL-GOAL: Portfolio website creation

Creating an impressive portfolio is essential because it becomes something you “own” and can take with you after graduation. It serves as a lasting reminder of the skills and knowledge you’ve gained, and more importantly, it acts as a valuable asset during job interviews. You’ll be able to showcase your work and demonstrate your expertise to potential employers with concrete examples.

This portfolio will be your professional showcase, representing what you’ve accomplished. It will help you stand out in interviews by giving you a tangible way to present your work. This portfolio is a reflection of you, so ensure it represents your best work and creativity—make it as awesome as you are!

DUE DATES: See the assignment’s Canvas page for the due date

LATE POLICY: See the syllabus

MEMBERSHIP: This project can be completed individually, or as a small group project with up to a maximum of 2 students per group. You can choose your own group members.

  • Everyone, even students working individually, must add themselves to the project group on Canvas (this is tedious but required by the Canvas grading system)
  • If you choose to work in a group, all group members must contribute equally.
  • Collaboration and teamwork are essential; ensure that the workload is evenly distributed among group members.

SUBMISSION:

  • The final project will be submitted to Canvas with the following content, you MUST include ALL of the following:
      • Landing page
      • Report
      • Technical details
        • Data collection
        • Data cleaning
        • EDA
        • unsupervised-learning
        • supervised-learning

IMPORTANT: The PDF submission WILL be automatically processed by Canvas in a plagiarism-checking and LLM usage software tool called turn-it-in. It is your responsibility to ensure that your submission is original and that you have properly cited all sources.

This is done to have a “static,” time-stamped version of your final submission.

OPTIONAL BONUS PRESENTATION: During the final week of class, you have the opportunity to present your project results for up to +7.5 bonus points. To qualify, you must create a concise 10-minute presentation with an accompanying slide deck. Simply opening your website and talking about it will not be sufficient. Sign-up will be voluntary and will be made available towards the end of the semester.

Code

For this project, you can use R or Python, or both. However, python is recommended, since it is more heavily represented in the class.

Python package (optional)

This is an optional component of the project, if you’d like, you can create a dedicated Python package for your project. The source folder for this package should be included in the root of your repository, and it can be imported into your processing scripts used in the various technical-details sections. If you create a package, it should be well-documented, with an additional tab on the navigation bar for the package documentation.

While a package would typically have its own GitHub repository, for this project, please include it within the same repository.

The skeleton for the package is not provided in the repo, but you can recycle what you created in past assignments.

Topic selection

Select a broad topic area

Start by selecting a broad topic area.

Here are some examples:

  • Bio and Health
  • Climate
  • Finance and Economics
  • Public Policy
  • Materials Discovery
  • Transportation
  • Education
  • Crime and Punishment
  • Politics and Government
  • Zoology and Botany
  • Social Phenomena

Narrow your focus

  • Narrow your focus to a topic that can realistically be addressed in a data driven way.
    • e.g. Study the effect of climate change on extreme weather
    • Avoid commonly used topics from Kaggle.
  • Claim your topic in the “project topic page in the shared documeent”

Even if multiple students choose similar topics, each portfolio must be original. Portfolios that are too similar will be reviewed for plagiarism and may result in Honor Council violation.

Data Science Questions

The data science life cycle starts with well-posed questions, similar to the scientific method. A data science question is a broad idea that can be broken down into 5 to 10 smaller questions, guiding your investigation.

  • “What effect is climate change having on frequency of extreme weather events? e.g hurricane, drought, forest fires, etc”

Here are some additional example questions:

  • Health & Medicine
    • What factors predict heart disease across different age groups?
    • How does cancer treatment effectiveness vary by demographics?
    • Can wearables predict the onset of diabetes?
  • Climate & Environment
    • What is the impact of deforestation on regional climates?
  • Education
    • How do socioeconomic factors affect student performance?
    • What is the impact of remote learning post-pandemic?
  • Social Science & Public Policy
    • How does income inequality correlate with crime rates?
    • What factors influence voter turnout?
  • Finance & Economics
    • What indicators predict stock market crashes?
    • How does inflation impact consumer spending?
  • Transportation
    • How has ride-sharing impacted taxi services?
    • What are the busiest transportation hubs, and how can congestion be reduced?
  • Crime & Law Enforcement
    • What factors predict recidivism in former inmates?
    • How do different policing strategies impact crime rates?
  • Sports & Entertainment
    • What factors predict an athlete’s long-term performance?
    • Can machine learning predict sports match outcomes?
  • Technology & Social Media
    • How do online reviews impact product sales?
    • What strategies drive viral social media campaigns?

Choose a topic you’re passionate about, and develop creative, “outside-the-box” questions to guide your project throughout the course.

GitHub

Your project will be fully transparent, with all source code hosted on GitHub. This platform will serve as the main repository for your project code, documentation, and website. Proper organization and regular updates are key for effective collaboration and project management.

IMPORTANT: Proficiency in GitHub for collaboration is a valuable addition to your resume. Being able to join a team and immediately contribute by solving problems and adding value is a highly sought-after skill. Now is the time to develop this expertise—embrace Git fully, become proficient, and graduate with a critical skill for your future career.

Repository Setup

  • You MUST use GitHub Classroom to create your project repository. This ensures TAs can access your code and track your progress.
  • Clone the repository to your local machine, which will provide a basic directory structure.

Expectations for GitHub Usage

Your grade will reflect how effectively you use Git, including:

  • Incremental progress on the project
  • The frequency and quality of commits
  • Repository structure and organization
  • Adherence to GitHub guidelines outlined below

Ensure regular commits to GitHub (e.g., git add, git commit, git push) to sync your work and maintain a smooth development process.

1. Use a Logical Repository Structure

  • Include a comprehensive README file that explains the purpose of the project.
  • Organize files logically to make navigation easier for collaborators and TAs.
  • Ensure all files are well-documented and the code is easy to follow.

2. Commit Regularly

  • Commit frequently with clear, meaningful commit messages that reflect the changes made.
    • Good commit message example: Added data cleaning script for tabular data
    • Poor commit message example: Fix

3. Data Storage

  • Do not store large data files in your repository.
    • Store raw data in the raw-data folder and processed data in the processed-data folder; these folders should be added to .gitignore.
    • Tip: Use external storage like Google Drive or GU Domains for large datasets and provide access links within the repository.

4. Syncing with GU Domains

  • Sync your GitHub repository with your GU Domains website before submission deadlines to keep everything up to date. (this should be fully automated)
  • Ensure your code repository and website are always in sync, particularly before the final submission, to avoid losing points.

5. Code Documentation

  • Provide clear and thorough documentation for each file and function in your project.
  • Include a README.md that outlines the project purpose, how to run the code, and any necessary dependencies.

Collaboration in Groups (If Applicable)

If you are working in a group, make full use of GitHub’s collaboration features:

  1. Task Assignment:
    • Assign tasks using GitHub Issues or Project Boards to keep track of progress.
  2. Branching and Pull Requests:
    • Use branches for feature development and pull requests for code reviews before merging into the main branch.
  3. Communication:
    • Maintain regular communication and conduct code reviews with your teammates to prevent conflicts.
  4. Equal Contribution:
    • Ensure equal contribution from all team members. Unequal contributions will negatively affect individual grades.
    • Note: Team members not contributing equally may be flagged by the group and penalized after review.
  5. Contribution Documentation:
    • Document each member’s contributions clearly in the collaborators.qmd file, detailing who worked on specific aspects of the project.
  6. Code Reviews:
    • Conduct peer code reviews before merging changes into the main branch to maintain quality and consistency.

Website project structure

Please at miniumum include the following pages in your website:

  • Landing page
  • Report
  • Technical details
    • Data collection
    • Data cleaning
    • EDA
    • Unsupervised-learning
    • Supervised-learning
    • LLM-usage
    • Progress-log

Please adhere closely to this structure, for consistency accross projects.

Sub-sections can be handles as markdown headers in the respective pages.

You can add more pages,and if you want, you can merge EDA and unsupervised learning into one page, since the are similar. Or make these section headers in the dropdown menu, for further sub-sections creation.

For example:

  • Landing page
  • Report
  • Technical details
    • Data collection
    • Data cleaning
    • EDA
    • Unsupervised-learning
      • Clustering
      • Dimensionality Reduction
    • Supervised-learning
      • Feature selection
        • regression
        • classification
      • Classification
        • Binary classification
        • Multi-class classification
      • Regression
    • LLM-usage
    • Progress-log

Important: Exactly what you put on these pages will be specific you your project and data. Some things might “make more sense” on one page rather than another, depending on your workflow. Organize your project in a logical way that makes the most sense to you.

A skeleton of the recommended version of the website is provided in the github classroom repository.

./
├── README.md
├── _quarto.yml
├── assets
│   ├── gu-logo.png
│   ├── nature.csl
│   └── references.bib
├── build.sh
├── data
│   ├── processed-data
│   │   └── countries_population.csv
│   └── raw-data
│       └── countries_population.csv
├── index.qmd
├── instructions
│   ├── expectations.qmd
│   ├── github-usage.qmd
│   ├── llm-usage.qmd
│   ├── overview.qmd
│   ├── quarto-tips.qmd
│   ├── topic-selection.qmd
│   └── website-structure.qmd
├── report
│   └── report.qmd
└── technical-details
    ├── data-cleaning
    │   ├── instructions.qmd
    │   └── main.ipynb
    ├── data-collection
    │   ├── closing.qmd
    │   ├── instructions.qmd
    │   ├── main.ipynb
    │   ├── methods.qmd
    │   └── overview.qmd
    ├── eda
    │   ├── instructions.qmd
    │   └── main.ipynb
    ├── llm-usage-log.qmd
    ├── progress-log.qmd
    ├── supervised-learning
    │   ├── instructions.qmd
    │   └── main.ipynb
    └── unsupervised-learning
        ├── instructions.qmd
        └── main.ipynb

Always strive to incorporate the following:

  • Structure: Use clear headings and subheadings to break down each section of your EDA.
  • Clarity: Provide concise explanations for all tables and visualizations, ensuring they are easy to interpret.
  • Code Links: Link to relevant code (e.g., GitHub) or embed code snippets for transparency and reproducibility.
  • Reproducibility: Make your EDA reproducible by providing access to the dataset, scripts, and tools you used.
  • Visualization: Use visualizations to convey key insights

Website Development

It is required that you build your website with Quarto.

Website Hosting

You MUST host your website on the Georgetown Domains web space.

No exceptions. You may NOT use anything other than Georgetown Domains to host your website. For example, no RPubs, WordPress, Squarespace, or any other website development toolset. Failure to comply with this rule will result in a ZERO.

The two audiences

Knowing your audience in data science writing is crucial because it shapes how you present information. Technical stakeholders may require detailed explanations of methodologies, while non-technical audiences need clear, simplified insights and data-driven conclusions. Tailoring your message ensures your analysis is both understandable and impactful, driving informed decision-making.

  • Examples of technical audiences include data scientists, software engineers, and IT professionals. These individuals expect detailed explanations of models, algorithms, methodologies, or system architectures, and they’re comfortable with technical jargon, such as discussing hyperparameters, programming frameworks, or machine learning techniques.

  • Non-technical audiences include executives, marketing teams, and clients. They prioritize high-level insights, actionable results, and visualizations that convey the impact of data without requiring an understanding of complex methods. For instance, a CEO may want to know how a model affects business strategy or revenue, without diving into the underlying technical details.

In this project you will cater to both audiences. This is done by having regions of your website for both audiences (see website struture)

General Tips and Expectations

Get started early

Remember, slow and steady wins the race

Making steady, incremental progress on a large project generally makes it more manageable. Rushing to throw something together under a tight deadline often turns the process into a nightmare.

Graduate level work

This is a graduate-level class, so each project should be viewed as specifications, not simple step-by-step requirements. Graduate-level work must be creative, individualized, and of high quality. To achieve an A-level grade, you are expected to exceed the specifications and create unique, novel solutions.

For example: If you’re asked to build visualizations to support your data science story, you won’t be told how many or what type of visualizations to create. This is up to you, based on your data and the creativity and quality you want to demonstrate.

We want you to move away from expecting someone else to tell you what to do, how to do it, and how much to do. Instead, you’ll adopt a professional approach—reviewing specifications provided in the assignments, determining what’s needed to exceed expectations, and demonstrating professional excellence.

There are countless ways to approach the project requirements, so be creative and thoughtful. Instructions outline the minimum requirements, but exceeding them will elevate the quality of your work.

Autonomy and Critical Thinking:

  • In the workplace, step-by-step instructions are rare. You’ll need to interpret broad requirements and deliver professional results. Producing high-quality, accurate work with limited guidance is a key professional skill.
  • At this stage, move away from asking, “Do I have to do XYZ?” Instead, critically analyze challenges. If something is unclear, investigate and break it down fundamentally.

Developing problem-solving skills is crucial. While it’s important to work independently for at least 10–20 minutes, if you’re still stuck after 30 minutes, seek help. Being resourceful is important, but knowing when to ask for assistance is equally valuable.

The intersection of skills and domain knowledge

“Data science” is essentially a collection of useful computational and mathematical skills (statistics, cloud computing, machine learning, coding, etc). However, to maximize your effectiveness, these skills should be applied to a domain of interest (e.g., materials science, finance, healthcare, etc). Focusing and learning about a particular domain will help you specialize and make you more marketable.

That beind said, don’t worry about choosing the “perfect” domain—it’s always possible to pivot later, as many of the skills learned, such as problem-solving, critical thinking, and self-education, are transferable across all fields.

What is “impact”?

Impact in science refers to the significance and influence of research, often measured by metrics like citations, impact factor of journals, and indices like h-index. These metrics reflect how widely recognized and valuable the work is within the scientific community. Such quanities are used to compare researchers and journals, and are used to determine grant funding and career opportunities.

  • Impact Factor (IF):
    • A measure of a journal’s influence, calculated by averaging the number of citations to articles published in the journal over the past two years.
    • Higher impact factors indicate a more influential journal.
  • Number of Citations:
    • The total count of how often a researcher’s work is cited by others, reflecting its influence within the scientific community.
    • More citations generally signal broader recognition or relevance of the research.
  • h-index:
    • A metric that measures both productivity and citation impact. An h-index of 10 means a researcher has 10 papers each cited at least 10 times.
    • Higher h-index indicates more influential and widely recognized work.
  • i10-index:
    • Counts the number of a researcher’s publications with at least 10 citations.
    • A straightforward measure of citation impact, commonly used by Google Scholar.
  • Importance of Citations:
    • Citations indicate that other researchers find the work valuable for their own research, increasing its perceived credibility and impact in the field.

What makes a good research project?

Professional academic or industrial research is all about discovery, improvement, and novelty. You don’t necessarily need to have a project that acheive the following, but here are some guidelines for what makes “high impact” projects:

In no particular order:

  • Novel computational tools: For example, development of a new Python package to tackle a class of problem which doesn’t have an existing suitable tool.
  • Creating more user-friendly tools: For example, there might be a great C++ code, but with no python analogue. Python is easier to use, so if you make a pythonic version of an existing tool, it may get higher adoption, provided it is more or less as efficient to the competitors.
  • More efficient tools or methods: Achieving something 1.25x, 2x, 10x or 10000x faster than existing methods, or creating a new code package that is more efficient than a previous one.
  • Novel methods: A completely new way of doing something (e.g. new classification algorithm)
  • Existing methods applied to new domains: Using established methods to solve problems in a novel domain, e.g. applying a particular classification methodology to a problem or dataset that no one has applied it to before. Extent of impact obviously depends on the importance of the domain or use-case.
  • Creation of novel Data Sets: Provides well-curated, clean datasets that can be used to address important scientific questions or problems.(often more useful if there is an accompanying API)
  • New insights or phenomena: Using data analysis techniques to uncover new insights or patterns that address key questions or problems. For example, discovering overarching governing rules (e.g., differential equations) that describe some observed phenomena.
  • Solves a Major Problem: Addresses a critical or unresolved issue in the field, offering a breakthrough or significant advancement.
  • Robust Data and Methodology: Employs sound, validated methodologies and high-quality data to ensure credibility and reliability (i.e. doing something rigorously, correctly, and generally better than the competition).
  • Interdisciplinary Impact: Influences multiple fields or areas of study, increasing the breadth of its significance.
  • High Citation Potential: Likely to be widely cited due to its significance, relevance, and applicability across different areas.

You can, of course, have multiple of these components in a single project, which will increase its prestige.

This is especially true when conducting academic research. Publications need to be novel and make a unique contribution to the body of human knowledge; otherwise, they will not be highly cited or considered particularly important.

Time management

80-20 Rule: This rule of thumb suggests that 80% of results come from 20% of causes. In other words, a small number of key factors drive the majority of outcomes. This principle applies to project management, where a few critical steps or decisions often determine the success of a project.

For example, it might take one week of steady work (30-40 hours) to complete 80% of a project, while the final 20% could take an additional four weeks.

Projects tend to expand to fill the time available. No creative project—whether a book, song, poem, or paper—is ever truly 100% complete. There is an asymptotic limit as \(t \rightarrow \infty\), and true perfection is unattainable. The key is knowing when to “call it done.” This might happen at 95% or 99% completion, but eventually, we all have to stop. Strive to take this project as far as possible, but remember to stop and “call it done” at some point.

Visualization guidelines

Visualizations are a critical component of your portfolio. Use them strategically to support your narrative. The more visual representations of your data, the better—higher-quality visualizations will result in a higher grade. Ensure that all graphics follow best practices:

  • Choose the right chart type: Match the chart to the data (e.g., bar for categories, line for trends).
  • Maintain simplicity: Avoid clutter and focus on the essential message.
  • Use appropriate scales: Ensure axes have correct and intuitive scaling to avoid misinterpretation.
  • Label axes clearly: Include meaningful axis labels with units (e.g., “Temperature (°C)” or “Revenue (USD)”).
  • Include descriptive titles: Provide a concise, informative title that explains the visualization’s main takeaway.
  • Ensure consistency: Use uniform color schemes, fonts, and styles across all charts in a presentation.
  • Highlight key data: Use contrasting colors or annotations to draw attention to important points or trends.
  • Keep proportions accurate: Maintain correct data-to-visual size relationships to avoid distortion.
  • Consider the audience: Tailor the level of detail and style to the audience’s technical proficiency.
  • Test readability: Ensure fonts, colors, and elements are clear and legible in various formats and sizes.
  • Use interactivity carefully: Interactive features should add clarity, not complexity, to the visual.

Coding

Practice First

While not required, practice is highly beneficial. It’s also a good habit to write your code from scratch, as this will build your problem-solving skills. You can use the code provided by professors as a reference, but always strive to write your own. Starting with a blank page is a valuable practice.

To get comfortable with the methods, review and modify the R and Python codes provided in class. Try applying these to your project data and experiment with creating small toy datasets, such as a CSV file or a text corpus. This helps you understand the structure of the data and what the algorithms are doing.

Prototype and develop on a small data set

If you have big data, ALWAYS prototype on a small subset of the data, so that your code runs fast so that you can develop quickly, without waiting several minutes for each code cell to run. Do this by including a downsampling hyper-parameter at the beginning of your code, e.g. 0.1. When the code is robust and finalized, you can set the downsampling factor to 1, run it on the complete data set, and let your computer run overnight.

It is not a crazy idea to do a “trial run” of the project first from start to finish with a very basic dataset, e.g. penguins,diabetes, or iris. Make sure the “toy” data set is similar to your planned real world data set, for example, if you are planning an NLP project, don’t use a image dataset for your development process.

This will have the following benefits:

  1. Clarifies Workflow: Understand the complete process from start to finish.
  2. Identifies Challenges: Spot potential issues early on.
  3. Validates Assumptions: Ensure methods and approaches are suitable.
  4. Enhances Skills: Improve technical skills through practice.
  5. Builds Confidence: Familiarity with tools and techniques.
  6. Refines Methods: Test and optimize analytical strategies.
  7. Estimates Resources: Better planning for time and resource allocation.
  8. Facilitates Communication: Clearly convey project goals and outcomes.
  9. Documents Process: Create a reference for reproducibility.
  10. Gathers Early Feedback: Obtain input for adjustments before full implementation.

https://scikit-learn.org/1.5/datasets/toy_dataset.html

Once that is working as a starter code-base you can swap it out for your full data later and start developing further for a more realistic real world project .

Debugging

  • Always remember the following Debugging Steps:

    • Step A: Copy the error message and search it online (Google or similar).
    • Step B: Look through forums or documentation to find a solution.
    • Step C: Implement the solution.
    • Step D: If you’re still stuck, ask for help from classmates, TAs, or professors.
    • Step E: Move on to the next issue and repeat the process.

(Note: You can also use ChatGPT for debugging, but be cautious as the solutions may sometimes be inaccurate or incomplete.)

Quarto Tips

File Types

You can decide when to use .qmd vs .ipynb for structuring your code, but I recommend the following guidelines:

  1. If the file contains any code (either in R or Python), ALWAYS use .ipynb.
  2. Do not mix R and Python in the same notebook.
  3. If the file is purely markdown without code, use .qmd.
  4. Use Quarto includes to modularize your content (see below for more details). This is also demonstrated in the project skeleton.

Quarto Includes

Quarto includes (e.g., {{< include _content.qmd >}}) are highly recommended for modularizing and organizing your content. While optional, they offer several advantages.

Note: You can include a .qmd file in a .ipynb file, but not vice versa.

Why Use Quarto Includes?

  1. Modularization: Breaking your project into smaller, reusable chunks simplifies the management of complex documents. You can work on specific sections without altering the entire project.

  2. Reusability: Includes allow you to reuse content blocks across multiple documents, making them ideal for repetitive sections like headers or footers.

  3. Consistency: By using includes, you ensure uniformity across your documents. Updating an include file will automatically apply the changes wherever it’s used.

  4. Simplifies Collaboration: In team settings, includes allow different contributors to work on separate sections simultaneously, reducing merge conflicts and making the project easier to maintain.

  5. Improved Organization: Includes help keep your main files clean and focused by loading content from separate, well-organized files. This makes your project more manageable and easier to navigate.

LLM usage

We believe that the adoption of LLM tools is inevitable and will be an important skill for success in your future career. Therefore, appropriate and acceptable use of LLM tools is encouraged for this project. Use them to accelerate your workflow and learning, but not as a replacement for critical thinking and understanding. Carefully review and process their output, use them judiciously, and avoid bloating your text with LLM-generated content. Overusing these tools often degrades the quality of your work rather than enhancing it.

Remember the following guidelines:

  • Use common sense: If you feel like you’re doing something questionable, you probably are. A good test is to ask yourself, “Would I openly tell the professor or classmates what I’m doing right now?” If the answer is no, you’re probably doing something you shouldn’t.
  • Cite your LLM use cases: Always cite when and how you’ve used LLM tools. This is a requirement for the project.
  • Is your use helping you grow professionally?: If your use of LLM tools is making you a more competent, efficient, and knowledgeable professional, you’re probably using them in an appropriate manner. If you’re using them as a shortcut to avoid work and gain free time, you’re using them incorrectly.

Citation

ALWAY CITE CONTENT OR IDEAS TAKEN FROM EXTERNAL SOURCES: e.g. websites, llm tools, papers

ALWAYS BE TRANSPARENT WHEN YOU ARE USING LLM TOOLS:

Please follow these guidelines:

  • General Tasks: Create and regularly update a dedicated LLM Transparency page to document how you are using LLM tools.
    • This page can serve as a “catch-all” for use cases that don’t involve content creation, such as reformatting your own ideas, commenting code that you wrote, or proofreading text, PDF summarization.
  • Content Creation: If non-original content (code or text) is generated by an LLM, you must also cite it on specific pages, just like any external source.
    • For non-original content, always provide a citation.
    • Cite the LLM tool after each chunk of text or code it generates, using a BibTeX. For example1

Acceptable use cases

Note: Various useful non-LLM research tools can be found here at the following link

You can use LLM tools for the following use cases

  • AI research tools
  • These include
    • re-formating text with LLM tools.
    • Code explaination “describe what this code is doing in prose”
    • Text summarization
    • Proofreading
    • chatGPT for project brainstorming
    • Using LLM tools to comment your code qualifies as an acceptible use case in this project. You can also use or code re-formatters such as black to increase the readability of your code.

Unacceptable use cases

DO NOT use ChatGPT or other LLM tools to write large portions of your text or code.

Effect on grade

If it is clear that you have used LLM tools to write large portions of your code or text, your grade will reflect this, likely in the range of 0% to 50% of the total points, depending on the quality of the work. LLM outputs still require significant polishing to fit into a well-written, cohesive narrative. If it is evident that you simply inserted large portions of LLM-generated content into your assignment without taking the time to refine it into a high-quality submission, your grade will reflect this, even if the usage does not rise to the level of plagiarism.

Plagiarism investigation

In extreme cases,the following actions will occur.

  1. One-on-One Investigation: You will meet with department faculty for a thorough review of your project. You will be asked to explain your work in detail, including what specific chunks of code do, why you made certain decisions, and how you reached your conclusions.

  2. Referral to the Honor Council: If, during this meeting, it is determined that you do not have sufficient understanding of the content that you claimed to have created, the case will be documented and sent to the honor council. This can result in a permanent mark on your transcript and may even lead to expulsion from the university.

References

1.
The following code cell was generate primarily via GPT-4o, OpenAI, chat.openai.com.