Nellie Cordova

Symbolic AI — agents that represent knowledge explicitly, reason over it, and can explain why they answered the way they did.

• Knowledge representation: semantic networks, frames, scripts, production systems, and formal logic — choosing a structure that makes the reasoning step tractable rather than describing everything in the world.
• Reasoning & problem solving: generate-and-test, means-ends analysis, problem reduction, planning, constraint propagation, configuration, diagnosis, and meta-reasoning, under bounded rationality — knowledge-guided search instead of brute force.
• Learning: learning by recording cases, case-based reasoning, incremental concept learning, version spaces, explanation-based and analogical reasoning, and learning by correcting mistakes.
• Agent mini-projects: a Sheep & Wolves river-crossing agent as a production system with breadth-first control (40/40, optimal on all 20 cases); a Block World planner using pure means-ends analysis (valid on 20/20, optimal on 16/20, sub-millisecond at 26 blocks) with the four misses traced to a single deadlock-parking choice; and a Monster Classification agent learning a version space from positive examples and near-miss negatives (19/20), where the one false negative was kept rather than fixed by loosening a threshold to fit it.
• Final project — ARC-AGI agent: a knowledge-based solver for 96 abstraction-and-reasoning problems, built on a fixed fingerprint–route–generate–test–select pipeline with about fifty grid operations in twenty-five rule families. A rule is accepted only when it reproduces every training pair exactly — no machine learning, no language-model prompting, no per-problem branches. Final score 82/96 (85.4%): 42/48 visible and 40/48 hidden, at a mean of 3.6 ms per problem across 99 passing unit tests.

Model families, optimization, and unsupervised structure — compared empirically rather than assumed.

• Supervised learning: compared decision trees, AdaBoost, KNN, SVM, and neural networks on the UCI Fertility and Kaggle Airline Satisfaction datasets — reached >92% F1 with decision trees while diagnosing overfitting and class imbalance.
• Randomized optimization: analyzed randomized hill climbing, simulated annealing, genetic algorithms, and MIMIC across three optimization problems, then applied them to neural network weight optimization.
• Unsupervised learning: K-Means and expectation-maximization clustering with PCA, ICA, random projection, and UMAP; evaluated with silhouette scores and mutual information, then retrained networks on reduced and augmented feature sets.
• Markov decision processes: compared policy iteration, value iteration, and Q-learning on the same environments to isolate where each one wins.

Architectures from CNNs to Transformers, with interpretability treated as part of the work.

• Convolutional networks: built and tuned CNNs for CIFAR-10 with dropout, data augmentation, and optimizer comparison (SGD vs. Adam).
• Recurrent models: implemented LSTM and GRU networks for text classification and language modeling, stabilizing training with gradient clipping and sequence-length tuning.
• Interpretability: applied saliency maps, GradCAM, and guided backpropagation, and explored adversarial examples, style transfer, and class visualizations.
• Seq2seq & Transformers: built attention-based seq2seq and Transformer models for machine translation, cutting validation perplexity from 19.1 to 4.9.
• Final project — Plate2Recipe: a multimodal system generating structured recipes from food images, pairing Vision Transformers for ingredient recognition with a fine-tuned GPT-2 and LSTMs trained on RecipeNLG. See it in Projects →

Classical baselines first, then embeddings, sequence models, and attention — each step measured against the last.

• Text classification: full pipeline over IMDb sentiment and AG News topics — cleaning, tokenization, vocabulary and bag-of-words — comparing Naive Bayes and logistic regression baselines against GloVe-embedding neural variants on accuracy and F1.
• Language modeling: token-level RNN language model in PyTorch with perplexity tracking and both greedy and temperature sampling.
• Attention: upgraded the language model to LSTM (using nn.LSTM and a from-scratch LSTMCell) and added encoder–decoder attention — scores to weights to context vector — for lower perplexity and more coherent continuations.
• Distributional semantics: trained CBOW and Skip-Gram embeddings from scratch and used GloVe for word analogies and cosine-similarity document retrieval.
• Key-Value Memory Networks: attention-based single-hop QA over external key–value facts, with a tractable dataset built from templated questions and distractor sampling. See it in Projects →

From tabular control to function approximation, including a replication of a foundational paper.

• TD(λ) replication: reproduced Sutton's 1988 Random Walk experiments with eligibility traces under both batch and online protocols, sweeping λ and α and recovering the characteristic U-shaped RMSE curve predicted by the bias–variance trade-off.
• Lunar Lander (DQN): built a PyTorch deep Q-network with experience replay, target-network updates, and ε-decay exploration; learning curves passed the 200-point "solved" threshold over 100-episode windows, and exponential ε-schedules proved more reliable than reward-based ones.
• Tabular control: SARSA on FrozenLake (on-policy) and Q-learning on Taxi-v3 (off-policy), with careful seeding, tie-breaking, and terminal-state handling.
• Planning & theory: value iteration on a custom dice-game MDP, derivation of the λ-return as a weighted sum of n-step targets, and a KWIK learner that abstains when its version space disagrees.
• Game theory: solved Rock–Paper–Scissors Nash equilibria as a minimax linear program in CVXPY.

Structure, dynamics, and statistical inference on real networks at scale.

• Structural analysis: analyzed social, biological, and infrastructure networks, validating spectral bounds, small-world effects, and power-law degree distributions with statistical testing.
• Centrality & communities: implemented PageRank, eigenvector, and betweenness centrality, and compared Louvain, greedy modularity, SBM, and HRG community detection — reaching >0.9 NMI against ground truth on benchmarks.
• Epidemic modeling: simulated SIS spreading on contact networks to identify epidemic thresholds, showing eigenvector centrality predicts outbreak speed more reliably than betweenness.
• Inference on large graphs: estimated network size and structure via sampling methods (capture–recapture, Horvitz–Thompson) on datasets too large to enumerate.

ML applied to noisy financial time series, benchmarked honestly against simple baselines.

• Strategy comparison: built a manual rule-based strategy and a bagged random-tree strategy learner on JPM (2008–2011) using SMA, Bollinger Bands, and MACD indicators.
• Benchmarking: evaluated both against a buy-and-hold benchmark — the manual rules outperformed in some periods while the learner underperformed due to instability, which is the result worth reporting.
• Sensitivity analysis: measured market-impact sensitivity to show how much feature engineering and hyperparameter choices drive outcomes in financial ML.

Algorithm design and complexity — the analytical backbone under everything else.

• Dynamic programming, divide-and-conquer, and the fast Fourier transform.
• Randomized algorithms, modular arithmetic, and RSA.
• Graph algorithms: strongly connected components, minimum spanning trees, and shortest paths.
• Max-flow / min-cut and linear programming.
• NP-completeness and reductions — recognizing when to stop looking for an exact algorithm.

The full design lifecycle — needfinding, ideation, prototyping, evaluation — run twice, individually and as a team.

• Individual project — Smart Transcript Display: designed an iMessage voice-note transcript feature for users with hearing impairments and for noisy environments. User surveys and evaluations identified the gaps; brainstorming produced three prototypes (Smart Transcript Display, Customizable Playback Speed, Contextual Transcripts), and the winning prototype went through extended evaluation.
• Group project — Discord notification redesign: used interviews, surveys, and heuristic evaluations to scope an adaptive, customizable notification system. Three prototypes (Smart Modes, Content Filters, PriorityHub) were designed and evaluated; PriorityHub won on user-specified priority handling. See it in Projects →
• My contribution to the group project: project ideation, the introduction, survey questions and heuristic evaluations, user interviews, the Content Filters prototype, design input on the final prototype, evaluation plans across needfinding, brainstorming, and second iteration, and the final survey analysis.

Concurrency, IPC, and remote services written in C against real OS primitives.

• Multithreading: scaled a GETFILE client with a pthread boss–worker pool and a mutex/condition-variable work queue, with clean shutdown via pthread_join.
• Shared memory IPC: built a proxy-to-cache path over POSIX shared memory (shm_open, mmap) using a turn-based producer/consumer handoff.
• gRPC file service: implemented a protobuf service with client-streaming Store and server-streaming Fetch, plus deadlines, write locks, and checksum/mtime-based synchronization.

Routing, software-defined networking, and internet-scale measurement — built and attacked in emulation.

• Topology & simulation: designed custom Mininet topologies and varied bandwidth, latency, and loss to analyze traffic behavior.
• Routing protocols: implemented a distributed spanning tree protocol in Python and a distance-vector (Bellman-Ford) protocol that handles negative edge weights and cycles, verifying convergence from routing logs.
• SDN firewall: built a POX/OpenFlow firewall with fine-grained MAC, IP, and transport-header policies, validated with Mininet and Wireshark.
• BGP: recreated prefix-hijack attacks in Mininet/Quagga to demonstrate traffic misdirection and recovery, and analyzed global routing data with PyBGPStream to measure prefix growth, AS-path evolution, and RTBH mitigation events.

Regression as a modeling and interpretation tool, not just a fit.

• Practiced: identifying which features actually matter, checking model assumptions, and reasoning about generalization.
• Carried forward: the predictive modeling in my undergraduate research, finding and then explaining the factors that influenced behavior.

Running an analysis reliably in code rather than by hand.

• Practiced: reproducible scripts, plotting, and numeric reasoning.
• Carried forward: the Python and R workflow I used for EDA, feature engineering, and evaluation as a research assistant.

Turning messy data into a decision someone can act on.

• Practiced: choosing metrics, summarizing results, and interpreting them for a reader who will not read the code.
• Carried forward: presenting research findings to faculty and student audiences — what the results meant, and what was worth trying next.

Thinking in pipelines — raw, to cleaned, to features, to insight.

• Practiced: structuring that flow end to end, and mining patterns out of datasets too large to eyeball.
• Carried forward: the EDA, feature engineering, and data cleaning that made up most of the real work in my undergraduate research.

Relational thinking, and a correctness mindset about retrieval.

• Practiced: tables, keys, and joins — with attention to whether a query returns what it claims to return.
• Carried forward: working confidently with structured survey data, joining, cleaning, and validating fields before trusting them.

Foundational vocabulary: services, deployment, and trade-offs.

• Practiced: the concepts and terminology rather than a build — enough to reason about where something should run and why.
• Carried forward: groundwork only. My hands-on cloud exposure came later and from the application side, on the payments platform at JPMorgan Chase.

The undergraduate project all six courses fed into.

• Took behavioral survey data through EDA, cleaning, and feature engineering, then modeled it with KNN, logistic regression, and hierarchical clustering.
• Presented the findings to faculty and student audiences with plots, tables, and an interpretation of what they meant.

Union County College · Cranford, NJ · 2014–2016

• Coursework: Adolescent Psychology, Educational Psychology, Fieldwork in Education.
• Honors: President’s High Honors, Phi Theta Kappa International Honor Society, Psi Beta National Honor Society.
• Activities: Secretary and founding member, Tennis Club.

I.E.S. San Juan · Seville, Spain · 2009–2011

• Coursework: Network Operating Systems, Computer Security, Network Services, Business and Entrepreneurship.
• Scope: installing, configuring, and maintaining standalone microcomputer systems and small local networks.
• Internship — CompuSpain: hardware installation and configuration, system assembly, troubleshooting and maintenance, inventory.