We implemented and compared video game non-player character design patterns, including Utility AI, behavior trees, goal-oriented action planning (GOAP), and finite state machines. We evaluated the strengths and weaknesses of each design pattern. Some metrics included the ease of implementation, effectiveness at accomplishing a given task, and variation in behavior.

In this project, I implemented a Behavior Tree. Behavior trees provide a modular and hierarchical framework in which each node represents a self-contained task or decision. This structure allows for flexible and scalable AI design, making it easy to add or modify behaviors without modifying a lot of code. Therefore, the implementation of this method was fairly simple. However, the transition between behaviors can feel a bit too rigid if not carefully designed. In our observations, this results in AI that feels unnatural/predictable.

Our group conducted an analysis to identify the key factors influencing the price of Pokémon cards. First, we combined two datasets: one containing general information about Pokémon cards and one containing their price trend data. In the preprocessing process, we cleaned the price information (converted from cents to dollars), standardized the date format, and converted text fields such as rarity and rank to numeric values. We also scraped the meta deck lists from a competitive Pokémon website and converted the data into CSV format using Python.

We grouped the data and used various visualization techniques such as heatmaps, scatter plots, line graphs, box plots, and K-means clustering to identify meaningful trends.

Our analysis yielded several key insights:

Our group developed a chatbot specifically designed for UTK admissions applications. We gathered comprehensive information about the UTK admissions process to build a custom dataset for training the chatbot.

We fine-tuned Meta's LLaMA-3-8B model (4-bit quantized using BnB). This model is small in size but performs very well. After carefully tuning the hyperparameters and improving the prompts, we generated a GGUF file to effectively deploy the model. We also tuned parameters such as temperature, top_p, and top_k to improve the quality and relevance of the responses.

As a result, our chatbot outperformed several other large language models regarding response accuracy and quality.

This research compares the performance of different versions of BERT-based language models on plot analysis. Using a one-shot testing approach, we explore how these models comprehend and respond to questions of varying difficulty.

To enhance model efficiency, headers, footers, and stopwords were filtered out from the text to enhance model efficiency. Preprocessed novel texts were divided into 512-word chunks to address the input size limits of BERT-based models. The Hugging Face pipeline was used to configure the models for question-answering tasks, with computation optimized on Google Colab's GPU.

Results showed RoBERTa excelled on simple questions, displaying strong comprehension. BERT, under-trained but generalizable, showed potential for task fine-tuning. SpanBERT, on the other hand, struggled significantly and failed to provide accurate answers.

Our team spearheads a project targeting the implementation of a Spiking Neural Network (SNN) to autonomously control a Crazyflie drone. Leveraging Evolutionary Optimization for Neuromorphic Systems (EONS), we develop and train the neural network through simulation, paving the way for seamless hardware integration.

Our focus encompasses a comprehensive evaluation of the drone's performance, stability, and flight skills. This innovative approach will allow a stable autonomous flight.

By pushing the boundaries of artificial intelligence and robotics, our project exemplifies technical prowess in advancing neuromorphic systems and autonomous drone technology.

Compassion Ministries is an organization that hosts large-scale food medical and dental drives throughout eastern Kentucky and eastern Tennessee. We worked on implementing an application to support Compassion Ministries' activities by managing their event schedule and volunteers.

This project utilizes React and NoSQL to manage data and implement applications. In this project, I implemented API routes to add organizations or get information about them through PUT and GET requests, or to exclude volunteers for a specific event from the list through DELETE requests. Also, I created webpage to verify volunteer roles and update or add organization information. While implementing this function, I mainly used MongoDB and Postman to learn the functions and handling data.

We developed a user-friendly website that provides comprehensive Pokémon information by leveraging the extensive data available through the RESTful API, PokéAPI. Implemented using HTML, JavaScript, and CSS, the website enables users to seamlessly access details on Pokémon, skills, and items through a simple name-based search functionality.

It dynamically fetches data from external websites, including PokéAPI, using the Fetch API, ensuring the continuous relevance and accuracy of the content. This approach exemplifies the advantages of utilizing RESTful API in web development.

The website dynamically lists related Pokémon names, move names, or item names in the search box using Levenshtein distance. We used Levenshtein distance with regex, enhancing the ability to handle typos and unfamiliar names. The voice recognition feature also leverages Levenshtein Distance's insertion, deletion, and substitution capabilities to improve accuracy, enhancing the user experience.

Wordle is a game where players have to guess the target word based on color hints such as gray, yellow, or green about the letter locations.

In our Wordle-solving project using Python, our group aimed to minimize attempts to find the target word using the Bayesian model, which makes decisions based on observed data or prior decisions. We used possible 5-letter words and Wordle answer histories as datasets, and leveraged letter frequency to identify the optimal start word.

As the group leader, I set the project's direction and adapted goals based on our progress. My contributions included implementing a Wordle solver using the Bayesian model and developing a method to determine the best start word using letter frequency. The Bayesian model, on average, achieved a success rate of 3.87 attempts to find the target word.

Our group project focused on identifying vulnerabilities in code snippets generated by Large Language Models (LLMs), with a specific focus on ChatGPT. Our research question probes into the security and reliability of code snippets produced by ChatGPT.

To evaluate these code snippets, we concentrated on four key metrics: naturalness, expressiveness, adequacy, and conciseness. These metrics serve as indicators of the vulnerability present in the ChatGPT-generated code.

Additionally, our analysis extends to categorizing ChatGPT-generated codes based on Common Weakness Enumeration (CWE) categories. This multifaceted approach allows us to comprehensively assess the security aspects of the code snippets generated by ChatGPT, contributing to awareness regarding the limitations of current Large Language Models.

While identifying the neural networks for music generation, our group utilized a Recurrent Neural Network (RNN) with an Autoencoder and Long Short-Term Memory (LSTM). We used TensorFlow in Python to implement RNN. The goal was to recognize patterns in existing classical songs and generate new compositions based on those patterns.

Using the MIDI format, we inputted various classic songs into the model and observed the output of new classical songs. To evaluate the model, we experimented with increasing the number of training epochs. Notably, as the epochs increased, the generated classical songs exhibited more diverse notes and intricate scales.

This project significantly advanced my understanding of machine learning and neural networks. The experience proved valuable during my later internship at ORNL, aiding in research related to machine learning.

Our group enhanced the design of the University Dining website to help students get information easily. We utilized TypeScript and Sass to improve the overall design and incorporated information such as restaurant locations and menus by storing them in JSON.

Key additions included zoom buttons and a star rating system, enhancing the website's completeness and functionality. We implemented a filter function for easier restaurant location and a pop-up window for quick access to detailed restaurant information.

This group project not only deepened my understanding of website production with Typescript and Sass but also provided valuable experience in collaborative programming including adjusting schedules.

I implemented three different pathfinding algorithms in Python using Pygame to demonstrate how they find the optimal path visually. The algorithm then calculates and displays the most optimal path from starting point to destination.

By inputting 1, 2, or 3, users can switch the pathfinding algorithm to A*, Dijkstra's, or Greedy Best-First Search, respectively. Users can set the starting point, destination, and obstacles by clicking the mouse, and start the pathfinding by pressing the space bar. To set points again, press the r button.

This gave me a better understanding of the differences between pathfinding algorithms and helped me articulate the strengths and weaknesses of each algorithm.

Extracting colors from images can be a tedious but necessary task. To simplify this process, I created a webpage that extracts colors from images and presents them as a palette.

Users can upload an image by clicking on the upload area or simply dragging and dropping the file. The program processes the image, extracting pixel values and analyzing their frequency. Similar colors are clustered using color distance calculations, and the nine most prominent colors are displayed as a clean, visually appealing palette.

A color picker tool allows users to manually select any color from the image that may not appear in the palette. Using color picker, users can change colors in image as well. If they don't like it, they can revert it. For convenience, by clicking on a color box, its corresponding hex value is copied to the clipboard. Additionally, users can click on the existing image or drag and drop a new file to replace it.

This project has deepened my understanding of color processing, including techniques for clustering similar hues and distinguishing variations in brightness.

I developed a webpage for searching for information on Pokémon cards, tailored to enthusiasts who appreciate the artwork of Pokémon cards. The webpage fetches data from the Pokémon TCG API and is built using HTML, JavaScript, and CSS.

It allows users to search for cards by name, artist name, or expansion name, displaying detailed information such as card artwork, card name, illustrator name, release date, rarity, and price. Users can toggle between full card details or just the artwork. Additionally, users can view statistics on the cards they've searched for, including release dates, prices, and other criteria.

The webpage also includes various features to enhance the search experience. Users can filter cards by card type or rarity and sort cards by release date, name, rarity, or price. There's even an option to share custom-filtered and sorted cards via a link, making it easy for users to share their discoveries with others.

Wordle is a game where players have to guess the target word based on color hints such as gray, yellow, or green about the letter locations.

After the Wordle-solving project, I implemented Wordle Solver on a webpage using HTML, JavaScript, and CSS. It operates almost similarly to the model implemented in Python, but the training and testing phases are omitted.

The Public-Facing Project, focused on GenAI and writing, addresses the diverse perspectives among students using generative AI like ChatGPT or Bing Chat. The project involves a surveying UTK students to explore their perceptions of ChatGPT, delving into usage patterns, reasons for usage or non-usage, and the ability to distinguish between texts generated by ChatGPT and those written by humans. Additionally, a website was implemented to share survey results and analysis.

The goal is to discuss the agreement or disagreement in perceptions, considering concerns and indifference regarding GenAI and writing within the student community.

The goal of this Kaggle competition is to take an image of a handwritten single digit and determine what that digit is. This competition is evaluated on the categorization accuracy of the predictions.

Using my understanding of Convolutional Neural Network (CNN), I implemented CNN model using Python to predict handwritten single digit and compare it to actual digit. My CNN Model shows 98-99% of accuracy to predict correct digit. I made a confusion matrix to visualize the accuracy as well.

I decided to convey my programming experience by creating a virtual portfolio website. Despite being my first attempt at HTML, JavaScript, and CSS, my familiarity with TypeScript and Sass from the Implementing the University Dining Website project proved beneficial.

Working with a new programming language was both refreshing and enjoyable. Overcoming challenges in website creation improved my HTML, JavaScript, and CSS skills. I focused on webpage colors and text layout, emphasizing the frontend aspect.

This virtual portfolio is an ongoing project; I plan to continuously update and enhance it. Feel free to reach out with any questions or suggestions!

In N-queens, the challenge is to place n-queens on an n*n chessboard without them threatening each other. Knight's Tour involves the knight passing through all squares of a certain-sized chessboard. I created C++ programs to solve these puzzles using recursion.

Taking it a step further, I implemented these puzzle-solving codes into websites using HTML, JavaScript, and CSS. Though challenging due to my limited knowledge of JavaScript at the time, I had fun learning and successfully completing the websites.

I coded AES and SHA-1 in C++, and Diffie-Hellman, RSA, and SRP in Python as part of my cryptography learning. All codes were hard-coded.

For AES, I referred to FIPS 197 and Rijndael Cipher Animation, which explained the processes thoroughly. It was challenging initially, but implementing each step in C++ turned out to be enjoyable.

SHA-1 implementation in C++ followed FIPS 180-4. Its unique padding algorithm and internal function complexity made it a bit challenging, but the process was fun.

Using Miller-Rabin Algorithms and Fast Modular Exponentiation, I found two primes for Diffie-Hellman, RSA, and SRP implementation in Python. The focus was on correctly encrypting, decrypting, and decoding at each step, providing valuable insights into how each cryptography method works.

I proficiently use Excel for data organization, specifically in managing schedules and expenses. Notable examples include Planner.xlsx and Statement of Expenditure.xlsx.

Planner.xlsx efficiently organizes schedules through tables and calendars. It allows easy categorization and filtering for a focused view of desired categories.

Statement of Expenditure.xlsx categorizes monthly consumption details, payment methods, categories, and places of purchase in a graph. Users can apply filters for a customized view, aiding in a clear understanding of spending history and effective financial management.

Voltorb Flip is a minigame of the Pokémon HeartGold and SoulSilver. This game is like a mix of Picross and Minesweeper, and I implemented it in C++ using vector and stringstream. This project, which I worked on when I was just starting to learn C++, helped me improve my understanding of vectors, for loops, functions, and stringstreams.

Later, I implemented my C++ work into web pages using HTML, JavaScript, and CSS.