
## Project Overview

Style Canvas is a web app I built to host and run AI style transfer models. A friend reached out with some models he'd trained and wanted a site where users could try them out. It turned into a fun systems project — build a way to serve AI inference jobs on demand and do it fast, scalable and **CHEAP**.

The models aren’t mine (and not really to my taste), but the infrastructure is solid. When I want to serve my own models, I can plug them right in.

---

## 🧱 Stack

- **Frontend**: `React + TypeScript`
- **Backend**: `NestJS`
- **Infra**: `AWS EC2 (GPU)`, `Cognito`, `DynamoDB`, `Stripe`
- **Model server**: Python running on-demand on a GPU instance

---

## 🔐 JWT Auth with Cognito

I used AWS Cognito for account management and session auth. When a user logs in, Cognito returns a JWT that gets stored in `localStorage` and attached to every request.

The backend verifies the token and sets the user's privileges using Cognito’s JWKS and Passport’s `JwtStrategy`:

```ts
super({
  jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
  secretOrKeyProvider: passportJwtSecret({
    jwksUri: `${COGNITO_DOMAIN}/.well-known/jwks.json`,
  }),
  audience: COGNITO_CLIENT_ID,
  issuer: COGNITO_ISSUER,
  algorithms: ['RS256'],
});
```

> Getting this flow working meant learning about JWTs — how they’re signed, verified, and decoded. Debugging it all gave me a solid understanding of a real world auth tool.

---

## ⚙️ On-Demand EC2 Inference

I initially containerized the models and got `Sagemaker` configured, but I quickly realized how expensive this option was going to be. I decided on a simpler method: when a user submits an image, I **spin up a GPU EC2 instance**, send the job to it, and shut it down when it's idle. This keeps costs near zero when no one's using the app and has a surprisingly low cold boot up period (10-15 seconds).

```ts
await exec(`aws ec2 start-instances --instance-ids ${ML_INSTANCE_ID}`);
await this.waitForServerReady();
const ip = await this.getServerIP();
```

Jobs are processed sequentially through a queue. The backend handles EC2 orchestration, checks token balances, and forwards the image to the model server:

```ts
const response = await fetch(`http://${ip}:5000/generate/image`, {
  method: 'POST',
  body: formData,
  headers: formData.getHeaders(),
});
```
---

## 💳 Stripe & Token System

Each user gets some free tokens on signup. Every time they stylize an image, one token is used. If they run out, they can:

- Buy more tokens (one-time purchase)
- Subscribe for unlimited monthly use

Prices are configured in Stripe with metadata that maps to token counts:

```ts
const lineItems = await stripe.checkout.sessions.listLineItems(session.id);
const price = lineItems.data[0].price;
const tokens = parseInt(price.metadata.tokens, 10);
await this.tokensService.adjustTokens(userId, tokens);
```

The backend verifies webhooks to confirm payments:

```ts
event = stripe.webhooks.constructEvent(payload, signature, STRIPE_SECRET);
```

> This was my first time using Stripe webhooks. They're clean, but I had to learn how to bypass body parsing in NestJS just for that one endpoint.

---

## 🖼️ Frontend

The React frontend handles:

- Auth state and JWT storage (via custom `AuthContext`)
- Image upload and model selection
- Polling job status every few seconds
- Showing styled results once they’re ready

```ts
const token = localStorage.getItem('accessToken');
if (token) {
  fetchUserProfile(); // hit /me with the token
}
```

When inference starts, the UI updates with job progress. If the EC2 instance needs to boot, it shows “Warming up…” until the backend is ready.

> Not fancy, but it works. Uploads feel snappy, the polling is reliable, and the state is reactive across login, logout, and retries.

---

## 🧠 What I Learned

- How JWTs actually work — signature validation, token lifetimes, and decoding with JWKS
- How to control EC2 instances via code and design on-demand compute flows
- How to process queued jobs and coordinate with an ML worker over HTTP
- How to use Stripe Checkout and webhooks to grant in-app credits
- How to structure and build a full-stack system that feels cohesive and responsive

---
But overall, it works. When someone uploads a photo and picks a style, a GPU spins up, runs inference, returns the result, and shuts down when it's done. And that feels pretty cool.


A full-stack platform for hosting AI models with on-demand GPU inference, JWT auth, and a simple token system. Built to be fast, scalable, and cheap.

Style Canvas


# LLM Generated Distribution-Based Prediction of US Electoral Results, Part I

## Research Summary

This paper proposes *Distribution-Based Prediction*, a novel method for using Large Language Models (LLMs) as predictive tools by analyzing output token probabilities as probability distributions. Instead of relying on silicon sampling (simulating individual personas), this approach treats the model’s output over integer vote shares as a direct reflection of its internal representation of the world. We apply this method to simulate U.S. presidential elections and evaluate bias, prompt noise, and algorithmic fidelity in LLMs.

## Motivation

Traditional approaches like silicon sampling attempt to simulate a population of human responses using demographic prompts. However, this method can introduce stereotype biases and is highly sensitive to prompt phrasing. Instead, we focus on using the model itself as a predictive agent, extracting probabilities directly from its output to forecast real-world outcomes, specifically electoral results.

This approach provides a cleaner, distributional view of what the model “believes” will happen, and allows rigorous comparisons between model output and historical or real-world data.

## Methodology

### Distribution-Based Prediction

- Constructed simple prompts to elicit vote share predictions from LLMs in the form of single integer outputs between 0 and 100.
- Used logits from LLMs to extract a distribution over possible vote shares per state and candidate.
- Avoided persona-based sampling entirely—LLMs act as election predictors, not simulated voters.

### Aggregating State Distributions

- For each state, calculated the probability that a candidate wins by summing over all pairwise outcome probabilities.
- Used these state-level win probabilities to compute national electoral vote distributions.
- Employed generating functions to efficiently calculate the full distribution of electoral college outcomes.

### Electoral Simulation

- Converted state-level win probabilities into electoral college predictions.
- Ran experiments comparing simulated results to real election outcomes in 2020 and projected results for 2024.

## Results

### Algorithmic Fidelity (2020 Benchmark)

- High agreement between predicted and actual state-level vote shares in 2020.
- Average prediction error was less than 0.5% per candidate per state.
- Predicted national electoral outcome matched the actual results.

### 2024 Forecast

- Distributional forecasts for the 2024 Trump vs. Harris matchup show Harris winning in 95% of simulations.
- Predicted electoral college outcome: Harris 303, Trump 235.

### Matchup Simulations

- Simulated hypothetical elections across 2016, 2020, and 2024 for multiple candidate pairs.
- Found consistent model preference toward Democratic candidates, especially in swing states.

## Key Insights

- **Prompt Noise**: Model outputs are highly sensitive to prompt phrasing; distributional evaluation can help quantify this.
- **Bias Detection**: Aggregated distribution comparisons reveal political bias tendencies in model outputs.
- **Model Scale Impact**: Larger models (e.g., LLaMA 3.2 90B) show more realistic distributions than smaller ones.
- **Silicon Sampling Limitations**: Demographic sampling via LLMs often reinforces stereotypes and lacks diversity in output distributions.

## Future Work

- Formalizing algorithmic fidelity metrics across broader prediction tasks.
- Evaluating prompt robustness and prompt ensemble averaging techniques.
- Extending the method to other domains like sports prediction, finance, and weather.
- Creating a public benchmark suite for distribution-based evaluation of LLMs.


## Research Team

- **Caleb Bradshaw**: Lead author, methodology and implementation
- **Caelen Miller**: Experimental analysis and evaluation
- **Dr. Sean Warnick**: Faculty advisor, systems theory and modeling

## Acknowledgments

This research was conducted at Brigham Young University under the mentorship of Dr. Sean Warnick, with computational resources and academic support provided by the Department of Computer Science.


This paper introduces Distribution-Based Prediction, a method for interpreting LLM output probabilities as predictive distributions. Applied to US elections, it enables analysis of model bias, prompt noise, and algorithmic fidelity.

LLM Generated Distribution-Based Prediction of US Electoral Results, Part I


# Taking the Derivative of a Story: A Novel Approach to Fiction Scene Segmentation

## Research Summary

This paper presents a novel method for identifying scene transitions in fiction by treating the narrative as a sequence of sentence embeddings. We calculate a “derivative” by measuring changes between adjacent embeddings, then use local minima in the smoothed derivative signal as potential scene boundaries. A neural classifier is trained on annotated scenes to filter out false positives.

## Motivation

Scene segmentation in fiction is a challenging NLP task with low inter-annotator agreement. Existing models often rely on classification or co-reference features, but struggle with generalization. Our approach reframes the task as a structural problem, leveraging embedding dynamics to detect changes in narrative momentum.

## Approach

- **Embedding Derivative**: Compute L2 differences between adjacent sentence embeddings.
- **Smoothing**: Apply Gaussian smoothing to extract trends.
- **Minima Detection**: Use local minima as candidate scene transitions.
- **Classification**: Train a neural network to classify these candidates using surrounding context.
- **Optional GPT-4 Check**: Use prompting to pinpoint scene boundaries within selected text spans.

## Results

- Achieves state-of-the-art accuracy on a 32-story dataset with diverse genres and lengths.
- Outperforms prior baselines on F1 and Pointwise Dissimilarity metrics.
- Shows robust performance across amateur and professional writing, though novel-length texts introduce more variance.

## Research Team

- **Michael DeBuse**, **Caelen Miller**, **Caleb Bradshaw**, **Abel Palmer**
- **Dr. Sean Warnick**: Faculty advisor

## Notes

This paper is currently under review at *Transactions of the Association for Computational Linguistics (TACL)*. A preprint is not available for distribution at this time.


This paper introduces a new method for scene segmentation in fiction by calculating a 'derivative' over sentence embeddings, using local minima as candidates for scene transitions.

|

CS and Mathematics @ BYU
I write about code, AI/ML, and whatever catches my eye.

Featured Work

Style Canvas

LLM Generated Distribution-Based Prediction of US Electoral Results, Part I

Taking the Derivative of a Story: A Novel Approach to Fiction Scene Segmentation

|

CS and Mathematics @ BYUI write about code, AI/ML, and whatever catches my eye.

Featured Work

Style Canvas

LLM Generated Distribution-Based Prediction of US Electoral Results, Part I

Taking the Derivative of a Story: A Novel Approach to Fiction Scene Segmentation

CS and Mathematics @ BYU
I write about code, AI/ML, and whatever catches my eye.