VRPG Study on Goal Reduction and Goal Optimization

Overview

This repository hosts the ongoing study detailed in the "VRPG for Fine-Tuning Goals and Path Finding" paper. The study delves into the realm of reducing complex text to guides and optimizing goals within the context of large language models. It represents an exploratory journey into the intersection of cognitive theories and computational linguistics, striving to create a general framework for goal optimization.

Study Highlights

• Focus: The study primarily focuses on transforming qualitative data into quantifiable goals, leveraging the power of large language models.
• VRPG Model: The core of the study revolves around the VRPG (Values, Resources, Problems, Goals) model, a novel approach to understanding and navigating the complexities inherent in setting and achieving various goals.
• Goal Optimization: The paper outlines methodologies for breaking down abstract goals into concrete steps and measurable outcomes.
• Matrix and Vector Approach: A key contribution is the development of a matrix and vector approach, adding a layer of sophistication to the analysis of how resources, values, and problems interact to influence goals.

Repository Contents

• Paper (vrpg-study.tex, vrpg-study.pdf): Full text of the "VRPG for Fine-Tuning Goals and Path Finding" paper.
• Reference implementation (vrpg/): a Python package that realizes the paper's "From Qualifiers to Quantifiers" step, turning free-text goal context into a quantifiable attainability score.
• Examples (examples/): the car- and aircraft-purchase worked cases from the paper, run end-to-end through the quantifier.
• Tests (tests/): unit tests for tagging, sentiment scoring, and the additive/vector models.

Installation

python3 -m venv .venv && .venv/bin/pip install -e ".[test]"

Quick Start

from vrpg import quantify

result = quantify(
    "Buy a car in 2023",
    [
        "I have a stable monthly income.",          # resource
        "I lack driving skills.",                  # problem
        "I want to reduce CO2 emissions.",         # value (routed by sign)
    ],
    mode="vector",  # or "additive"
)
print(result.interpretation)
# e.g. "X = 0.69 (favorable); resources/values outweigh problems, with intensity ||R-P|| = 4.18."

Run the worked examples and the test suite:

.venv/bin/python -m examples.car
.venv/bin/python -m examples.aircraft
.venv/bin/python -m pytest -q

How the Implementation Maps to the Paper

Paper concept	Code
"a function that tags these classes" (Identifying Objects)	vrpg/tags.py
Sentiment-derived positive/negative magnitude ("From Qualifiers to Quantifiers")	vrpg/sentiment.py
Value swapping into R or P by sign (replaces the placeholder even/odd rule)	vrpg/model.py (_route_values)
Additive model X = sum(R) - sum(P)	vrpg/model.py (score_additive)
Vector model X = sum_i (r_i - p_i) with `
Fixed facet taxonomy satisfying the paper's "same dimensions" requirement	vrpg/model.py (FACETS)
End-to-end text -> numbers -> score	vrpg/quantifier.py

Empirical Validation

vrpg/validate.py tests whether the VRPG score X predicts whether a real goal is attained, on real crowdfunding data. Each Kickstarter project maps to a goal attempt (goal = project name, statements = description sentences, outcome = funded/failed).

Fetch the data and run the evaluation:

.venv/bin/pip install -e ".[validate]"
.venv/bin/python data/fetch_kickstarter.py --rows 2000 --out data/kickstarter.csv
.venv/bin/python -m vrpg.validate --csv data/kickstarter.csv --out figures

Results (2000 real projects; see the paper's "Empirical Validation" section and figures/results.json):

	Full sample (n=1996)	Rich-text subset (n=761)
mean X | funded	3.54	5.54
mean X | failed	3.44	4.77
AUC(X)	0.502	0.531
Welch t p-value	0.69	0.086
AUC(goal amount) [baseline]	0.645	0.618
AUC(X + goal)	0.646	0.624

Honest finding: the score is in the correct direction (funded projects score higher; positive logistic coefficient) and the signal strengthens with text richness, but the simplified sentiment-based quantifier is weak (AUC ~0.53 on the rich subset, at chance on one-sentence blurbs), and is dominated by goal size. This empirically confirms the paper's central claim that the qualitative-to-quantitative step is the bottleneck, and motivates the LLM-based quantifier as the next step.

VRPG-Neural: a learned model with VRPG at its heart

vrpg/neural.py replaces the hand-coded VADER quantifier with one that is learned end-to-end, while keeping the proven VRPG structure (tagging, sign-routed value contribution, signed aggregation) as fixed differentiable layers. The model's decision function is the VRPG score: p(funded) = sigmoid(X). Magnitudes are constrained to [1, 10] so Theorem 7's bound still holds, and the score is exactly the sum of signed per-statement contributions (Theorem 1, in soft form).

Train on the free Colab/Kaggle GPU via the bundled notebook:

1. Open notebooks/train_vrpg_neural.ipynb in Google Colab (Runtime → T4 GPU).
2. Run all cells. It clones this repo, fetches the real Kickstarter data, trains with early stopping, and reports test_auc_X vs the VADER baseline and the goal-amount baseline.

Or run locally (CPU, slower):

.venv/bin/pip install -e ".[neural]"
.venv/bin/python -m vrpg.neural --csv data/kickstarter.csv --epochs 200 --device auto --out figures

The notebook compares four numbers — test_auc_X (learned VRPG), test_auc_vader_X (hand-coded), test_auc_goal (confound baseline), test_auc_X_plus_goal (combined) — so you can see whether learning the quantifier closes the gap the validation identified. Saved to figures/neural_results.json and figures/vrpg_neural.pt.

How to Use This Repository

• For Researchers: Dive into the paper for a comprehensive understanding of the VRPG model and its applications in goal optimization using large language models.
• For Developers: Explore the reference implementation and examples to see how the theoretical concepts are translated into practical algorithms.
• For Enthusiasts: Leverage the supplementary materials to gain additional insights into the study and its broader implications in the field of AI and cognitive sciences.

Contributing

We welcome contributions from the community. Whether it's suggesting improvements, extending the existing model, or providing new insights, your input is valuable. Please refer to the contributing guidelines for more details on how to participate.

Citation

If you use the findings or methodologies from this study in your work, please cite the paper as follows:

@article{vrpg_study_2023,
  title={VRPG for Fine-Tuning Goals and Path Finding},
  author={Saransh Sharma},
  year={2023},
  url={https://github.com/Cynsar-Foundation/vrpg}
}

License

The contents of this repository are licensed under the MIT License, allowing for both academic and commercial use, with appropriate credit.

Contact

For queries or collaborations, please reach out to the author or the research team at help@cynsar.foundation.