Will Kusch

Building whatever I think is cool and useful.

Design inspired by Brittany Chiang.

Hi, I'm Will! I'm really passionate about a few things, and one of them is building cool projects. I started in SaaS about two years ago, pivoting after an e-commerce exit, and have been in a constant state of learning. Some of my strong suits are building beautiful UI/UX, AI, and Python. I mainly just like creating solutions to problems.

Experience

Relativum

Business Development Tool | September 2024

SaaS that takes user insights and aggregates them and performs thorough machine learning and algorithmic analysis.

APIs Firebase Flutter UI

Co-Founder of Posteries

Custom Posters | August 2022

Co-founded a poster store with completely organic marketing, focusing on SEO. Sold the store and its assets within 6 months of launching.

E-Commerce Organic Marketing Business Development

Style Mime

Artificial Intelligence | January 2024

Still in development. Utilizing advanced techniques to mimic a users style on a minimal dataset, all while fooling AI detectors.

Artificial Intelligence Google Cloud Flutter UI

Public Projects

Adversarial AI Detector Attack

Implemented an attack on AI detectors based on academic research, exploring vulnerabilities in AI detection systems.


import requests
import torch
from transformers import BertTokenizer, BertForSequenceClassification, pipeline
from torch.nn.functional import softmax
from dotenv import load_dotenv
import os
                            
load_dotenv()
api_key = os.getenv('gptzero_api_key')
                            
# GPT Zero Detector - Add your API key to .env or swap to another detector
def ai_detector(generated_text):
    gptzero_api_key = api_key
    url = "https://api.gptzero.me/v2/predict/text"
    payload = {"document": generated_text, "version": "2024-04-04"}
    headers = {
        "x-api-key": gptzero_api_key,
        "Content-Type": "application/json",
        "Accept": "application/json"
    }
    response = requests.post(url, json=payload, headers=headers)
    if response.status_code == 200:
        data = response.json()
            if data['documents']:
                class_probabilities = data['documents'][0]['class_probabilities']
                        
View on

Text Style Transfer using RepEng

Developed a project utilizing RepEng for text style transfer, demonstrating proficiency in natural language processing techniques.


import json
import random
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
import nltk
from sentence_transformers import SentenceTransformer
from sklearn.metrics.pairwise import cosine_similarity
from sklearn.decomposition import PCA
from typing import List
from transformers import AutoModelForCausalLM, AutoTokenizer, PreTrainedModel, PreTrainedTokenizerBase, BitsAndBytesConfig
from tqdm import tqdm
import gc
from nltk.tokenize import word_tokenize
from nltk.translate.bleu_score import sentence_bleu

nltk.download('punkt', quiet=True)

class DatasetEntry:
    def __init__(self, positive, negative):
        self.positive = positive
        self.negative = negative

# Repeng library modifications
                        
View on

Dynamic Browser Content

Created a tool to generate dynamic content based on browser interactions, showcasing web development and user experience skills.


const express = require('express');
const cookieParser = require('cookie-parser');
const Groq = require('groq-sdk');

const app = express();
app.use(cookieParser());

const groq = new Groq({
    apiKey: '',
});

// Endpoint to set cookies
app.get('/set-cookies', (req, res) => {
    // Set different cookies for testing
    res.cookie('userID', '12345');
    res.cookie('favoriteColor', 'blue');
    res.cookie('preferredLanguage', 'en');
    res.cookie('location', 'New York');
    res.cookie('lastVisited', '2023-06-02');
    res.send('Cookies set successfully!');
});

// Main page
app.get('/', async (req, res) => {
    const startTime = Date.now();                            
                        
View on

Analyzing What Makes Text Human

Did thorough deep learning and statistical analysis to determine what makes text human in the eyes of an AI detector.


import pandas as pd
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
import torch.nn.functional as F
from torch.utils.data import DataLoader, TensorDataset
from torch.cuda.amp import autocast, GradScaler
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from transformers import BertTokenizer, BertModel
import spacy
import nltk
from nltk.tokenize import word_tokenize
from nltk.tag import pos_tag
from nltk.corpus import wordnet
import re
from tqdm import tqdm
from textstat import textstat
from collections import Counter
import scipy.stats as stats
import ast
import seaborn as sns
import matplotlib.pyplot as plt                         
                        
View on

Float2Int

Implemented a neural network architecture that uses fixed-point arithmetic rather than floating point numbers.


import numpy as np
import time
from sklearn.datasets import fetch_openml
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

sf = 2**20
max_int32 = 2**31 - 1

class FixedPointArray:
    def __init__(self, data):
        self.data = np.clip(np.round(data * sf), -max_int32, max_int32).astype(np.int32)

    @property
    def shape(self):
        return self.data.shape

def int_to_float(x):
    return x / sf

def int_add(a, b):
    if isinstance(a, (int, np.integer)) and isinstance(b, (int, np.integer)):
        return np.clip(a + b, -max_int32, max_int32)
    else:
        return np.clip(np.add(a, b, dtype=np.int64), -max_int32, max_int32).astype(np.int32)                                                
                        
View on

Betting on Assignment Procrastination

Developed a basic algorithm and Tkinter UI to validate the idea of betting on assignment procrastination.


from datetime import datetime, timedelta
import random
import logging

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

class Assignment:
    def __init__(self, id: str, name: str, open_date: datetime, due_date: datetime):
        self.id = id
        self.name = name
        self.open_date = open_date
        self.due_date = due_date
        self.bets = []

class Bet:
    def __init__(self, user, amount: float, selected_date: datetime, assignments):
        self.user = user
        self.amount = amount
        self.selected_date = selected_date
        self.assignments = assignments
        self.completed = False
        self.potential_return = None

class User:
    def __init__(self, name: str, balance: float):
                        
View on

Artifical Nose

Created an artifical nose using an Arduino and a Swift app to display live data.


void scanI2C() {
    Serial.println("\nI2C Scanner");
    byte error, address;
    int nDevices = 0;
    
    for (address = 1; address < 127; address++) {
        Wire.beginTransmission(address);
        error = Wire.endTransmission();
    
        if (error == 0) {
        Serial.print("I2C device found at address 0x");
        if (address < 16) Serial.print("0");
        Serial.println(address, HEX);
        nDevices++;
        } else if (error == 4) {
        Serial.print("Unknown error at address 0x");
        if (address < 16) Serial.print("0");
        Serial.println(address, HEX);
        }
    }
    
    if (nDevices == 0)
        Serial.println("No I2C devices found\n");
    else
        Serial.println("done\n");
    }
                        
View on

Video Embeddings

Take a video and extract clips from it using natural language using embedded frames.


import torch
from transformers import CLIPProcessor, CLIPModel
import cv2
import numpy as np
from PIL import Image
import matplotlib.pyplot as plt
from tqdm import tqdm
import imageio
from IPython.display import display, Image as IPyImage

%matplotlib inline

device = "cuda" if torch.cuda.is_available() else "cpu"
print("Using device:", device)

model_name = "openai/clip-vit-large-patch14"
model = CLIPModel.from_pretrained(model_name).to(device)
processor = CLIPProcessor.from_pretrained(model_name)

def sample_video_clips(video_path, clip_length=8, frame_stride=2):
    cap = cv2.VideoCapture(video_path)
    frames = []
    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
    fps = cap.get(cv2.CAP_PROP_FPS)
    frame_list = []
                        
View on

Get in Touch!

Whether you have a project, a job opportunity, or just want to chat, I'm always excited to connect with people.

Reach Out to Me