Building whatever I think is cool and useful.
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.
Business Development Tool | September 2024
SaaS that takes user insights and aggregates them and performs thorough machine learning and algorithmic analysis.
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.
Artificial Intelligence | January 2024
Still in development. Utilizing advanced techniques to mimic a users style on a minimal dataset, all while fooling AI detectors.
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']
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
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();
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
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)
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):
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");
}
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 = []
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