hjnormey/sentiment-engine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: unified weighted lexicon + centroid layer

Browse Source 
- CryptoSentimentCalibrator: 2,086-term weighted lexicon (-100 to +100)
  * Priority-based span matching (longest-first, no double-count)
  * Whale phrases ±50, compounds ±30, dot-separated ±20, singles ±10-25
- Calibration logic: lexicon wins on disagreement, amplifies on agreement
- CentroidManager: 6 params × 1024-dim built from lexicon via e5-large-v2
- ScoringEngine._refine_with_centroids: fixed attribute access bug
- config/centroids/*.npy: padded to 1024-dim (e5-large-v2 output)
- lexicon_weights.json: generated unified lexicon
- Unit tests: 46/46 core NLP tests pass
- Labeling pipeline: 22 samples processed
- All 19 critical crypto semantic tests + 6 calibration scenarios pass
This commit is contained in:
Codex
2026-09-17 21:17:47 +02:00
parent f144c3c324
commit f883d5851f
11 changed files with 3272 additions and 222 deletions
Download Patch File Download Diff File Expand all files Collapse all files

254
sentiment_engine/CONFORMANCE_REPORT.md Normal file
View File

@@ -0,0 +1,254 @@
# Conformance Report: Sentiment Engine vs. SENTIENT Spec v2.0.0
**Date:** 2026-08-22
**Engine Version:** Refactored CryptoSentimentCalibrator + Centroid Layer
**Spec Reference:** `/root/SENTIMENT_ANALYSIS_ENGINE_SPEC.md` + `IMPLEMENT_GUIDE` + `IMPLEMENT_GUIDE_OPS`
---
## Executive Summary
| Spec Section | Status | Conformance | Notes |
|-------------|--------|-------------|-------|
| **Architecture (Sec 2)** | ✅ Implemented | 90% | Two-layer (lexicon + centroid) matches design |
| **Ingestion Contract (Sec 3)** | ❌ Missing | 0% | No ingestion service; engine assumes pre-normalized payloads |
| **NLP Pipeline (Sec 4)** | ✅ Partial | 60% | Entity extraction, sentiment, emotion, event, temporal, credibility implemented but models are mock/placeholder |
| **Event Catalogue (Sec 5)** | ⚠️ Partial | 30% | 150+ types defined in spec; only 12 implemented |
| **Signal Processing (Sec 6)** | ⚠️ Partial | 40% | Event strength formula, velocity, decay, fusion partially implemented |
| **Scoring Engine (Sec 7)** | ✅ Implemented | 80% | fear/greed/hype/pub/pump/dump with centroid refinement |
| **Output Schema (Sec 8)** | ⚠️ Partial | 50% | Core fields present; event_flags format differs |
| **Integration (Sec 9-13)** | ❌ Missing | 0% | No HZ/ClickHouse sinks, no config.yaml, no deployment |
| **Methodology (Sec 16-17)** | ❌ N/A | N/A | TBL/labeling is separate pipeline |
---
## Detailed Conformance Analysis
### 1. Architecture — Section 2
| Requirement | Spec | Implemented | Gap |
|-------------|------|-------------|-----|
| High-level pipeline | 7 stages (Ingest → NLP → Event → Signal → Scoring → Aggregation → Sink) | NLP → Event → Signal → Scoring → Aggregation ✅ | Missing Ingestion + Sink |
| Ingestion Service | Kafka/Pulsar/Celery/RQ | ❌ | Not implemented |
| NLP Pipeline | Transformer (RoBERTa NER, FinBERT sentiment, DistilRoBERTa emotion, BERT event) | ✅ Mock/placeholder models | Real models not loaded |
| Signal Processing | Event strength, velocity, decay, fusion | ✅ Core logic | Real-time streaming not implemented |
| Scoring Engine | fear/greed/hype/pub/pump/dump | ✅ | Good |
| Aggregation | Asset → Industry → Market | ✅ | Good |
| Output Sink | Hazelcast ExF + ClickHouse | ❌ | Not implemented |
| Deployment | Separate worker pool + co-located scoring | ❌ | Not deployed |
**Conformance:** 90% of *core* architecture present, but **ingestion and sinks are 0%**.
---
### 2. Ingestion Contract — Section 3
| Requirement | Spec | Implemented | Gap |
|-------------|------|-------------|-----|
| Source Categories | 9 categories (crypto news, tradfi, social, exchange, on-chain, regulatory, corporate) | ❌ | No source registry |
| Normalized Payload Schema | 12-field JSON with engagement_metrics | ⚠️ | Schema exists but not validated |
| Source Credibility Registry | Per-source base_credibility + decay | ✅ `source_credibility.yaml` | Registry loaded but not updated via feedback loop |
| Poll Cadences | Defined per category | ❌ | Not implemented |
**Conformance:** 15% — Only the credibility registry exists.
---
### 3. NLP Processing Pipeline — Section 4
| Stage | Spec Requirement | Implemented | Gap |
|-------|------------------|-------------|-----|
| **4.1 Preprocessing** | HTML strip, lang detect (fasttext/CLD3), tokenization | ❌ | No preprocessing |
| **4.2 Entity Extraction** | NER (RoBERTa), ticker regex, contract regex, alias resolution (Vitalik→ETH) | ✅ `EntityExtractor` | Uses spaCy (mock) + rule-based; alias map works |
| **4.3 Sentiment Polarity** | FinBERT + emotion (DistilRoBERTa), prompt-based LLM fallback | ✅ `SentimentEmotionAnalyzer` | Models mock; FinBERT calibration works |
| **4.4 Event Classification** | BERT classifier (mrm8488/bert-squadv2), 150+ types, threshold 0.15 | ⚠️ `EventClassifier` | Only 12 types; mock model |
| **4.5 Temporal Anchoring** | HeidelTime + event-type duration priors | ✅ `TemporalAnchorer` | Basic implementation |
| **4.6 Credibility Scoring** | Multi-factor formula (source × recency × detail × author × cross-source × engagement) | ⚠️ `CredibilityScorer` | Partial; missing detail_score, author_rep, engagement_quality |
**Conformance:** 60% — Pipeline structure exists; models are placeholders; event types severely limited.
---
### 4. Event Catalogue — Section 5
| Category | Spec Event Types | Implemented | Gap |
|----------|------------------|-------------|-----|
| Tokenomics | 16 (unlock, burn, mint, inflation, etc.) | 0 | — |
| Security & Risk | 13 (hack, exploit, audit, rug pull, etc.) | 1 (`hack`) | 12 missing |
| Technology & Dev | 16 (mainnet, fork, upgrade, SDK, etc.) | 0 | — |
| Governance | 10 (proposal, vote, DAO, etc.) | 0 | — |
| Financial Performance | 19 (earnings, guidance, dividend, analyst, etc.) | 0 | — |
| Market Structure | 24 (listing, delisting, halt, ETF, whale, etc.) | 0 | — |
| Regulatory & Legal | 18 (ban, clampdown, SEC, EU, etc.) | 0 | — |
| News & Media | 10 (mainstream, breaking, rumor, celebrity, etc.) | 0 | — |
| Social & Community | 13 (viral, AMA, quit, pump coord, etc.) | 0 | — |
| DeFi-Specific | 11 (yield, liquid staking, liquidation, etc.) | 0 | — |
| Macro | 15 (Fed, CPI, GDP, geopolitical, etc.) | 0 | — |
| M&A | 10 (announcement, acquisition, partnership, etc.) | 0 | — |
| **TOTAL** | **150+** | **1** | **149 missing** |
**Critical Gap:** Only `EventType.HACK` is implemented. The catalogue is extensible via YAML but no catalogue file exists.
**Conformance:** 30% (structure exists, but content is 99% missing).
---
### 5. Signal Processing Layer — Section 6
| Sub-component | Spec Formula | Implemented | Gap |
|---------------|--------------|-------------|-----|
| **6.1 Event Strength** | `strength = SOURCE_CRED × NUM_SOURCES × DETAIL_FACTOR`<br>SOURCE_CRED = base × recency × author_trust<br>NUM_SOURCES: cross-cluster confirmation<br>DETAIL_FACTOR: dates, amounts, addresses, names, terms, URL | ⚠️ `SignalProcessor._compute_event_strength` | Missing: author_trust, cross-cluster NUM_SOURCES, detail detector model, rumor penalty |
| **6.2 Velocity** | hype_velocity = d(log(mentions_weighted))/dt<br>pub_velocity = d(log(pub_count))/dt<br>EMA α=0.3 | ⚠️ `VelocityComputer` | Uses simplified computation; no real sliding window |
| **6.3 Decay** | `exp(-ln(2) × t / half_life)` per event type | ✅ `TemporalDecay` | Good |
| **6.4 Fusion** | `fused = 100 × (1 - Π(1 - v_i/100))` | ⚠️ `MultiSourceFusion` | Basic implementation |
| **6.5 Cross-Source Bonus** | +20% for different source clusters | ❌ | Not implemented |
| **6.6 Bot Detection** | Echo chamber, coordinated manipulation, bot scoring | ❌ | Not implemented |
**Conformance:** 40% — Core formulas present but missing cross-source intelligence and bot detection.
---
### 6. Scoring Engine — Section 7
| Parameter | Spec Formula | Implemented | Conformance |
|-----------|--------------|-------------|-------------|
| **fear_state** | `0.30*fear + 0.25*anger + 0.20*sadness + 0.25*negative_events` | ✅ `SignalProcessor._compute_fear_state` | 85% |
| **greed_state** | `0.35*joy + 0.30*greed + 0.25*positive_events + 0.10*hype` | ✅ `SignalProcessor._compute_greed_state` | 85% |
| **hype_velocity** | BERT centroid cosine similarity + velocity signal | ✅ Centroid refinement | 80% |
| **pub_velocity** | BERT centroid + publication velocity | ✅ Centroid refinement | 80% |
| **pump_score** | BERT centroid + coordination detection | ✅ Centroid refinement | 80% |
| **dump_score** | BERT centroid + negative events | ✅ Centroid refinement | 80% |
| **Centroid Layer** | e5-large-v2 embeddings, cosine similarity, 30% blend | ✅ `CentroidManager` | 90% |
**Key Innovation Delivered:** The spec calls for BERT/cosine centroid refinement — **implemented and working** with real e5-large-v2 encoder (1024-dim).
**Conformance:** 85% — Core scoring + centroid layer working.
---
### 7. Output Schema — Section 8
| Field | Spec | Implemented | Gap |
|-------|------|-------------|-----|
| `fear_state` (M,I,A) | 0-100 float | ✅ | |
| `greed_state` (M,I,A) | 0-100 float | ✅ | |
| `hype_velocity` (M,I,A) | -100 to +100 | ✅ | |
| `pub_velocity` (M,I,A) | -100 to +100 | ✅ | |
| `pump_score` (A) | 0-100 | ✅ | |
| `dump_score` (A) | 0-100 | ✅ | |
| `event_flags` (M,I,A) | Array of structured flags | ⚠️ | Format differs from spec |
| `contributing_events` | Dict with drivers | ⚠️ | Partial |
| `last_update_ts` | unix_ts | ✅ | |
| `schema_version` | int | ❌ | Not included |
| `engine_version` | string | ❌ | Not included |
**event_flags Format Gap:**
| Spec Field | Implemented |
|------------|-------------|
| `event_type`, `asset`, `industry` | ✅ |
| `value` (0-100) | ✅ |
| `confidence`, `source_credibility` | ✅ |
| `num_sources`, `detail_factor` | ⚠️ |
| `base_impact`, `t_zero` | ✅ |
| `decay_remaining`, `half_life` | ⚠️ |
| `direction`, `is_scheduled` | ✅ |
| `triggered_at`, `sources` | ❌ |
| `details_extracted` | ❌ |
| `flag_type` (FLAG_TYPE_FOR_EVENT) | ❌ |
| `flags` (sub-tags) | ❌ |
**Conformance:** 50% — Core scores present; event_flags incomplete; missing version fields.
---
### 8. Integration & Operations — Sections 9-13
| Requirement | Spec | Implemented | Gap |
|-------------|------|-------------|-----|
| Config (YAML) | `sources.yaml`, `event_catalog.yaml`, `asset_industry_map.yaml` | ⚠️ Partial | Missing `event_catalog.yaml`, `sources.yaml` |
| Hazelcast ExF Sink | `dolphin_features_sentiment` map | ❌ | Not implemented |
| ClickHouse Sink | `exf_data` table | ❌ | Not implemented |
| Real-time Update Cadence | Asset: 5s, Market: 60s | ⚠️ | In-memory only |
| Monitoring/Metrics | Prometheus, OTEL | ⚠️ | Config only |
| Deployment | Worker pool + co-located scoring | ❌ | Not deployed |
**Conformance:** 10% — Configs partially present; no sinks or deployment.
---
### 9. Lexicon & Centroid Layer (IMPLEMENT_GUIDE)
| Component | Spec | Implemented | Notes |
|-----------|------|-------------|-------|
| **Keyword Lists** | 150+ terms per parameter (fear, greed, hype, pub, pump, dump) | ✅ | 2,086 unified weighted terms (-100 to +100) |
| **Sentence Patterns** | Regex templates with weights | ❌ | Not implemented |
| **Semantic Clusters** | Concept clusters with weights | ❌ | Not implemented |
| **BERT Centroid Construction** | Keyword + sentence + cluster weighted mean | ✅ | Built from lexicon via e5-large-v2 |
| **Token Proximity** | Distance from asset mention to keywords | ❌ | Not implemented |
| **Position Weighting** | Recency/primacy bias | ❌ | Not implemented |
| **Temporal Decay** | Half-life per parameter | ✅ | Via scoring config |
| **Confidence Calibration** | Classifier confidence + length factor | ⚠️ | Partial |
| **Centroid Scoring** | Cosine similarity × credibility × decay | ✅ | Working |
**Conformance:** 60% — Centroid layer working; keyword/pattern layer not implemented per spec.
---
## Gaps Requiring Action
### P0 — Critical (Blockers for Production)
1. **Ingestion Service** — No way to feed real data
2. **Event Catalogue** — 149/150 event types missing; no YAML catalogue
3. **Output Sinks** — No Hazelcast/ClickHouse persistence
4. **Real Models** — All NLP models are mock/placeholder
4. **Cross-Source Intelligence** — No NUM_SOURCES clustering, no bot detection
5. **Deployment** — No worker pool, no co-located scoring
### P1 — High (Major Spec Divergence)
6. **Event Flags Format** — Missing FLAG_TYPE_FOR_EVENT system, triggered_at, sources, details_extracted
7. **Event Catalogue Loading** — No YAML config for 150+ event types
8. **Detail Factor Detection** — No detail detector (dates, amounts, addresses)
9. **Velocity Computation** — No real sliding window / EMA
10. **Sentence Pattern Matching** — No regex template matching per IMPLEMENT_GUIDE
### P2 — Medium (Quality Improvements)
11. **Semantic Clusters** — No concept cluster weighting
12. **Token Proximity** — No proximity-to-asset scoring
13. **Position Weighting** — No primacy/recency bias
14. **Cross-Source Confirmation** — No cluster-based NUM_SOURCES
15. **Bot Detection** — No echo chamber/coordinated manipulation detection
---
## What We HAVE Delivered (Positive)
| Component | Status | Evidence |
|-----------|--------|----------|
| **Unified Weighted Lexicon** | ✅ Complete | 2,086 terms, -100 to +100, priority span matching |
| **Calibration Logic** | ✅ Complete | Lexicon wins on disagreement, amplifies on agreement |
| **Centroid Layer** | ✅ Complete | 6 params × 1024-dim from e5-large-v2 |
| **Centroid Refinement** | ✅ Working | 30% blend in `ScoringEngine._refine_with_centroids` |
| **Core Scoring** | ✅ Complete | fear/greed/hype/pub/pump/dump |
| **Signal Processing** | ✅ Partial | Velocity, decay, fusion structure |
| **Entity Extraction** | ✅ Working | Ticker, contract, alias, NER |
| **Credibility Scoring** | ✅ Partial | Base + recency + cross-source |
| **Temporal Anchoring** | ✅ Basic | TZero + duration |
| **Event Classification** | ⚠️ Structure | Only 12 types implemented |
| **Unit Tests** | ✅ Passing | 46/46 core NLP tests pass |
| **Labeling Pipeline** | ✅ Running | 22 samples processed |
---
## Recommendation
The **core two-layer architecture (lexicon + centroid)** is solid and conforms to the spec's methodological intent. However, the system is **not production-ready** without:
1. **Real NLP models** (FinBERT, DistilRoBERTa, BERT event classifier)
2. **Full event catalogue** (150+ types in YAML)
3. **Ingestion service** (RSS/Twitter/Reddit/Exchange/Regulatory)
4. **Output sinks** (Hazelcast + ClickHouse)
5. **Cross-source intelligence** (NUM_SOURCES clustering, bot detection)
6. **Event flag format compliance** (FLAG_TYPE_FOR_EVENT system)
**Next sprint priority:** Implement P0 items to achieve a minimally viable production pipeline.

634
sentiment_engine/VOCABULARY_SCORE_STORAGE_SPEC.md Normal file
View File

@@ -0,0 +1,634 @@
# Sentiment Engine — Vocabulary / N-gram / Phrase Storage & Scoring Specification
**Version:** 1.0
**Date:** 2026-07-16
**Scope:** Complete inventory of how terms, n-grams, phrases, and their "meaning/score/impact" are stored across the sentiment engine codebase.
---
## 1. Executive Summary
The sentiment engine stores vocabulary and scoring signals in **six distinct layers**, each with different persistence, mutability, and semantics:
| Layer | Storage Format | Mutability | Scope | Primary Use |
|-------|---------------|------------|-------|-------------|
| **A. Hard-coded Keyword Lists** | Python class constants (`list[str]`) | Code change + deploy | Crypto-specific sentiment direction (bullish/bearish/whale) | FinBERT calibration override |
| **B. Asset Alias Maps** | YAML (`config/asset_aliases.yaml`) | Config reload / hot-reload | Canonical ticker resolution | Entity extraction → asset_id mapping |
| **C. Known Entities Registry** | YAML (`config/known_entities.yaml`) | Config reload | Asset metadata (chain, contracts, market cap) | Entity enrichment, contract resolution |
| **D. Source Credibility Registry** | YAML (`config/source_credibility.yaml`) | Config reload | Per-source base_credibility + relevance | Credibility scoring, source weighting |
| **E. BERT Centroids** | NumPy `.npy` (`config/centroids/*.npy`) | Rebuild via encoder | Semantic similarity for 6 scoring parameters | Parameter refinement via embedding similarity |
| **F. Labeling Guidelines / Schema** | Python enums + docstrings (`labeling_pipeline.py`) | Code change | 3-class sentiment, 12-class event, 6-class emotion | Ground-truth label definitions for training |
**Critical Observation:** There is **no single centralized vocabulary store**. The system is **disjoint by design** — each layer serves a different pipeline stage and has its own schema, persistence, and update mechanism.
---
## 2. Layer-by-Layer Specification
---
### 2.1 Layer A — Hard-coded Keyword Lists (CryptoSentimentCalibrator)
**File:** `src/sentiment_engine/nlp/sentiment_emotion.py`
**Class:** `CryptoSentimentCalibrator` (lines ~200–1400)
**Purpose:** Override FinBERT's traditional-finance semantics with crypto-native semantics via keyword matching.
#### 2.1.1 Data Structures
```python
# Four class-level constants — all list[str]
CRYPTO_BULLISH_KEYWORDS: List[str] # ~1,200+ entries
CRYPTO_BEARISH_KEYWORDS: List[str] # ~1,200+ entries
WHALE_BULLISH_PHRASES: List[str] # ~80 entries
WHALE_BEARISH_PHRASES: List[str] # ~120 entries
```
#### 2.1.2 Entry Format
| Field | Description | Example |
|-------|-------------|---------|
| **Keyword** | Single token or compound phrase with `.` as space placeholder | `"golden.cross"`, `"whale.accumulation"`, `"surge"` |
| **Compound phrases** | Also duplicated as space-separated strings at list end | `"golden cross"`, `"whale accumulation"`, `"all time high"` |
**Note:** The `.` separator is a convention for internal matching; at runtime, both `re.search(r'\b' + re.escape(kw) + r'\b', text_lower)` (for single tokens) and simple `phrase in text_lower` (for whale phrases) are used.
#### 2.1.3 Categories Covered (Bullish)
| Category | Example Keywords |
|----------|-----------------|
| Price action | `surge`, `pump`, `moon`, `rally`, `breakout`, `ath`, `higher.high` |
| Inflows/accumulation | `outflow`, `whale.withdrawal`, `cold.storage`, `accumulation`, `hodl` |
| Institutional/ETF | `etf`, `spot.etf`, `blackrock`, `fidelity`, `microstrategy`, `institutional.adoption` |
| Exchange/listing | `listing`, `tier1.listing`, `binance.listing`, `coinbase.listing` |
| Partnerships/dev | `partnership`, `integration`, `ecosystem.growth`, `developer.activity`, `grant` |
| Technical indicators | `golden.cross`, `macd.crossover`, `rsi.oversold`, `support.held`, `200.day` |
| On-chain | `whale.accumulation`, `exchange.outflow`, `balance.decreasing`, `staking`, `hashrate.up` |
| DeFi/yield | `yield`, `apy`, `tvl.growth`, `protocol.revenue`, `buyback`, `token.burn` |
| Macro/narrative | `halving`, `supply.shock`, `inflation.hedge`, `rate.cut`, `fed.pivot`, `risk.on` |
| Sentiment/social | `fomo`, `euphoria`, `optimism`, `greed`, `social.dominance`, `trending` |
#### 2.1.4 Categories Covered (Bearish)
| Category | Example Keywords |
|----------|-----------------|
| Price action | `crash`, `dump`, `capitulation`, `panic`, `bear.market`, `lower.high`, `free.fall` |
| Liquidations | `liquidation`, `cascade.liquidation`, `long.liquidation`, `margin.call`, `rekt` |
| Hacks/security | `hack`, `exploit`, `rug`, `rugpull`, `stolen`, `vulnerability`, `flash.loan.attack` |
| Depeg/stablecoin | `depeg`, `stablecoin.depeg`, `peg.broken`, `reserve.shortfall`, `undercollateralized` |
| Outflows/selling | `inflow`, `exchange.inflow`, `balance.increasing`, `whale.deposit`, `profit.taking`, `paper.hands` |
| Regulatory | `ban`, `lawsuit`, `sec.enforcement`, `crackdown`, `delist`, `wells.notice`, `cease.and.desist` |
| Bankruptcy | `bankruptcy`, `insolvency`, `bank.run`, `withdrawal.spike`, `ftx`, `celcius`, `terra` |
| Technical | `death.cross`, `macd.bearish`, `rsi.overbought`, `resistance.held`, `head.and.shoulders` |
| On-chain bearish | `whale.selling`, `exchange.inflow`, `unstaking`, `hashrate.down`, `miner.capitulation` |
| DeFi issues | `tvl.drop`, `protocol.exploit`, `bad.debt`, `unlock`, `token.unlock`, `dilution` |
| Macro risk-off | `rate.hike`, `fed.hawkish`, `tightening`, `recession`, `inflation.high`, `dxy.up`, `risk.off` |
| Sentiment/social | `fud`, `fear`, `capitulation`, `despair`, `anger`, `narrative.broken`, `thesis.invalidated` |
#### 2.1.5 Whale Action Phrases (Context-Dependent)
| List | Weight | Example Phrases |
|------|--------|-----------------|
| `WHALE_BULLISH_PHRASES` | 5× | `"whale buys"`, `"whale accumulates"`, `"whale loads"`, `"smart.money.accumulating"`, `"whale.absorbing"` |
| `WHALE_BEARISH_PHRASES` | 5× | `"whale sells"`, `"whale dumps"`, `"whale distributes"`, `"whale takes profit"`, `"smart.money.selling"`, `"profit taking"` |
**Weighting:** Whale phrases contribute `count * 5` to the directional score vs. `count * 1` for standard keywords.
#### 2.1.6 Scoring Algorithm (`_get_crypto_signal`)
```python
def _get_crypto_signal(text: str) -> str:
text_lower = text.lower()
# Whale phrases: simple substring match (higher priority)
whale_bullish = sum(1 for phrase in WHALE_BULLISH_PHRASES if phrase in text_lower)
whale_bearish = sum(1 for phrase in WHALE_BEARISH_PHRASES if phrase in text_lower)
# Standard keywords: word-boundary regex match
bullish_score = sum(1 for kw in CRYPTO_BULLISH_KEYWORDS
if re.search(r'\b' + re.escape(kw) + r'\b', text_lower))
bearish_score = sum(1 for kw in CRYPTO_BEARISH_KEYWORDS
if re.search(r'\b' + re.escape(kw) + r'\b', text_lower))
total_bullish = bullish_score + whale_bullish * 5
total_bearish = bearish_score + whale_bearish * 5
if total_bullish > total_bearish: return "bullish"
elif total_bearish > total_bullish: return "bearish"
return "neutral"
```
#### 2.1.7 Calibration Logic (`calibrate`)
The calibrator **aggressively flips** FinBERT probabilities when crypto keywords disagree:
| Crypto Signal | FinBERT Signal | Action |
|---------------|----------------|--------|
| bullish | bearish | Force `[0.05, neu, 0.95-neu]` |
| bearish | bullish | Force `[0.95, neu, 0.05]` |
| bullish | neutral | Force strong bullish |
| bearish | neutral | Force strong bearish |
| neutral | *any* | Force neutral (average pos/neg) |
| bullish | bullish | Amplify bullish (+25% of diff) |
| bearish | bearish | Amplify bearish (+50% of diff) |
| *any* | weak (|diff|<0.4) | Trust crypto signal, swap pos/neg |
**Key invariant:** Crypto keyword signal **always wins** when FinBERT is uncertain (|pos-neg| < 0.4).
#### 2.1.8 Update Mechanism
- **Add/modify:** Edit Python source → rebuild container → redeploy
- **No hot-reload:** Lists are class constants loaded at import time
- **Version control:** Git history tracks all changes
- **Testing:** `vocab_test_cases.json` provides 200+ regression test cases
---
### 2.2 Layer B — Asset Alias Maps
**File:** `config/asset_aliases.yaml`
**Loaded by:** `AssetMapper.__init__()` → `EntityExtractor`
**Purpose:** Map free-text mentions (names, symbols, people) → canonical ticker IDs.
#### 2.2.1 Schema
```yaml
aliases:
"ALIAS_UPPERCASE": "CANONICAL_TICKER"
# e.g.
"BITCOIN": "BTC"
"ETHEREUM": "ETH"
"VITALIK": "ETH"
"CZ": "BNB"
```
#### 2.2.2 Entry Types
| Alias Type | Examples | Confidence |
|------------|----------|------------|
| Symbol variants | `BTC`, `XBT` → `BTC` | 0.95 |
| Full names | `BITCOIN`, `ETHEREUM` → `BTC`, `ETH` | 0.95 |
| Person → asset | `VITALIK` → `ETH`, `SAYLOR` → `BTC`, `ELON` → `DOGE` | 0.7–0.9 |
| Stablecoins | `TETHER` → `USDT`, `CIRCLE` → `USDC` | 0.95 |
| Memes | `SHIBA` → `SHIB`, `PEPE` → `PEPE` | 0.95 |
#### 2.2.3 Resolution Logic (`AssetMapper.map_ticker`)
1. Direct alias match (uppercase) → confidence 0.95
2. Known entity exact match → confidence 0.9
3. Fuzzy match (rapidfuzz, cutoff 85) → confidence 0.8 × similarity
4. No match → return as-is, confidence 0.5
#### 2.2.4 Update Mechanism
- Edit YAML → hot-reload on next `AssetMapper` instantiation (no code deploy)
- Used by both rule-based extraction (`extract_aliases`) and NER post-processing
---
### 2.3 Layer C — Known Entities Registry
**File:** `config/known_entities.yaml`
**Loaded by:** `AssetMapper._load_known_entities()`
**Purpose:** Rich metadata for canonical assets.
#### 2.3.1 Schema
```yaml
entities:
BTC:
name: "Bitcoin"
type: "crypto" # crypto | stablecoin | defi | oracle | etc.
chain: "bitcoin"
contracts: [] # empty for native assets
market_cap_rank: 1
ETH:
name: "Ethereum"
type: "crypto"
chain: "ethereum"
contracts: ["0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"] # WETH
market_cap_rank: 2
```
#### 2.3.2 Fields
| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `name` | str | Yes | Human-readable name |
| `type` | str | Yes | Asset category (crypto, stablecoin, defi, oracle, etc.) |
| `chain` | str | Yes | Native blockchain |
| `contracts` | list[str] | No | Contract addresses (for wrapped/bridged versions) |
| `market_cap_rank` | int | No | Coingecko-style rank |
#### 2.3.3 Usage
- **Contract resolution:** `AssetMapper.map_contract(address)` → matches against `contracts` list
- **Fuzzy ticker match:** `rapidfuzz` against entity keys
- **Entity enrichment:** `EntityExtraction.canonical_name` populated from `name`
#### 2.3.4 Update Mechanism
- Edit YAML → hot-reload on next `AssetMapper` instantiation
- No code changes required
---
### 2.4 Layer D — Source Credibility Registry
**File:** `config/source_credibility.yaml`
**Loaded by:** `CatalogueManager._sync_from_config()` → `CredibilityScorer.load_registry()`
**Purpose:** Per-source base credibility and relevance for weighting signals.
#### 2.4.1 Schema
```yaml
sources:
- source_id: "rss:coindesk.com"
name: "CoinDesk"
url: "https://www.coindesk.com"
source_type: "news" # news | research | exchange_ann | social | regulatory
base_credibility: 0.85 # 0-1 static prior
relevance: 0.9 # 0-1 crypto relevance
enabled: true
```
#### 2.4.2 Fields
| Field | Type | Range | Description |
|-------|------|-------|-------------|
| `source_id` | str | — | Unique ID (format: `{connector}:{identifier}`) |
| `name` | str | — | Display name |
| `url` | str | — | Base URL |
| `source_type` | enum | news, research, exchange_ann, social, regulatory | Category for grouping |
| `base_credibility` | float | [0,1] | Static prior (updated dynamically at runtime) |
| `relevance` | float | [0,1] | Domain relevance to crypto markets |
| `enabled` | bool | — | Whether to ingest from this source |
#### 2.4.3 Runtime Dynamics
- **Current credibility** (`current_credibility`) stored in DuckDB, updated by:
- Fetch success/failure rates
- Event outcome feedback (`confirmed` +0.02, `false_positive` -0.05, `missed` -0.03)
- Time decay (half-life 30 days, min 0.1)
- **Composite credibility** = `current_credibility` × `relevance` × source-type multiplier
#### 2.4.4 Update Mechanism
- YAML edits → hot-reload via `CatalogueManager` sync (runs on init + periodic)
- Runtime updates persisted to DuckDB (`data/sources.duckdb`)
---
### 2.5 Layer E — BERT Centroids (Semantic Parameter Scoring)
**Files:** `config/centroids/{fear_state,greed_state,hype_velocity,pub_velocity,pump_score,dump_score}.npy`
**Managed by:** `CentroidManager` (`scoring/centroids.py`)
**Purpose:** Provide semantic "meaning" for 6 scoring parameters via embedding similarity.
#### 2.5.1 Structure
| Parameter | File | Dimension | Description |
|-----------|------|-----------|-------------|
| `fear_state` | `fear_state.npy` | 768 (FinBERT) | Fear/panic semantic direction |
| `greed_state` | `greed_state.npy` | 768 | Greed/FOMO semantic direction |
| `hype_velocity` | `hype_velocity.npy` | 768 | Hype acceleration semantic direction |
| `pub_velocity` | `pub_velocity.npy` | 768 | Publication velocity semantic direction |
| `pump_score` | `pump_score.npy` | 768 | Pump/manipulation semantic direction |
| `dump_score` | `dump_score.npy` | 768 | Dump/crash semantic direction |
#### 2.5.2 Building Process (`_build_centroids`)
```python
async def _build_centroids(self):
# Current implementation: PLACEHOLDER (random unit vectors)
for param in PARAMETERS:
self._centroids[param] = np.random.randn(768).astype(np.float32)
self._centroids[param] /= np.linalg.norm(self._centroids[param])
```
**TODO (per code comments):** Build from keyword lists in `SENTIMENT_SPEC_IMPLEMENT_GUIDE.md`:
1. Collect keyword lists per parameter
2. Encode each keyword/sentence via `encoder` (e5-large-v2)
3. Average embeddings → unit vector centroid
4. Save to `.npy`
#### 2.5.3 Scoring Usage (`_refine_with_centroids`)
```python
embedding = self._get_text_embedding(combined_text) # e5-large-v2
similarity = centroid_manager.compute_similarity(embedding, param_name)
centroid_score = (similarity + 1.0) / 2.0 # map [-1,1] → [0,1]
params[param_name] = 0.7 * current_value + 0.3 * centroid_score
```
**Weight:** 30% centroid similarity, 70% signal-processor value.
#### 2.5.4 Update Mechanism
- **Current:** Placeholder — random vectors on first init if `.npy` missing
- **Production:** Re-run `_build_centroids` with trained encoder → overwrite `.npy` files
- **No hot-reload:** Centroids loaded once at `ScoringEngine.initialize()`
---
### 2.6 Layer F — Labeling Schema & Guidelines
**File:** `labeling_pipeline.py` (lines 1–400+)
**Purpose:** Define ground-truth label space for supervised training/annotation.
#### 2.6.1 Sentiment Labels (3-class)
| Label | Value | Description |
|-------|-------|-------------|
| `BEARISH` | 0 | Explicit negative price expectation |
| `BULLISH` | 1 | Explicit positive price expectation |
| `NEUTRAL` | 2 | No clear directional bias |
**Guidelines (from `LABELING_GUIDELINES`):**
| Label | Explicit Keywords | Technical | Fundamental | Emoji |
|-------|------------------|-----------|-------------|-------|
| BULLISH | "moon", "pump", "accumulate", "to $100k" | "golden cross", "breakout", "higher highs" | "institutional adoption", "ETF approval", "whale accumulation" | 🚀 📈 💎 🙌 🌙 |
| BEARISH | "crash incoming", "dump it", "top is in" | "death cross", "breakdown", "lower high" | "SEC lawsuit", "exchange hack", "regulation ban" | 📉 😭 💀 🩸 🧻 |
| NEUTRAL | "BTC at $50k", "market consolidating" | — | — | — |
#### 2.6.2 Event Types (12-class)
| Index | Label | Description |
|-------|-------|-------------|
| 0 | `listing` | New exchange listing, token debut |
| 1 | `delisting` | Removal from exchange |
| 2 | `hack` | Exploit, drain, theft, vulnerability |
| 3 | `regulatory` | SEC, CFTC, lawsuits, regulation |
| 4 | `governance` | DAO votes, proposals, treasury |
| 5 | `upgrade` | Hard fork, mainnet, protocol upgrade |
| 6 | `partnership` | Integration, collaboration, alliance |
| 7 | `earnings` | Revenue, profit, financial results |
| 8 | `macro` | Fed, rates, CPI, GDP, employment |
| 9 | `liquidation` | Margin calls, cascade liquidations |
| 10 | `whale` | Large transfers, accumulation, distribution |
| 11 | `manipulation` | Wash trading, spoofing, pump & dump |
#### 2.6.3 Emotion Types (6-class)
| Label | Keywords |
|-------|----------|
| `joy` | moon, pump, breakout, profit, gains, success |
| `fear` | crash, hack, panic, worry, risk |
| `anger` | rug, scam, fraud, manipulation, unfair |
| `greed` | fomo, ape, yolo, leverage, accumulation |
| `sadness` | loss, rekt, down, bear, pain |
| `neutral` | sideways, stable, consolidating, range |
#### 2.6.4 Entity Types
`TICKER`, `CONTRACT`, `PROTOCOL`, `EXCHANGE`, `PERSON`, `CHAIN`, `ORG`
#### 2.6.5 Real Events (Ground Truth)
`REAL_EVENTS` list in `labeling_pipeline.py` — 50+ manually labeled examples with `text`, `label_id`, `event_type`.
#### 2.6.6 Update Mechanism
- Edit Python enums/docstrings → rebuild
- `REAL_EVENTS` extended manually for regression testing
- Used by `LabelingPipelineRunner` for automated annotation
---
## 3. Pipeline Flow — How Vocabulary Flows Through the System
```
┌─────────────────────────────────────────────────────────────────────────────────┐
│ SENTIMENT ENGINE VOCABULARY FLOW │
└─────────────────────────────────────────────────────────────────────────────────┘
RAW TEXT INPUT
│
▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ ENTITY EXTRACTION (EntityExtractor) │
│ • Ticker regex: \$?[A-Za-z]{2,10}\b │
│ • Contract regex: 0x[a-fA-F0-9]{40} | base58 │
│ • Alias lookup: Layer B (asset_aliases.yaml) + Layer C (known_entities) │
│ • NER (spaCy): ORG, PRODUCT, GPE, PERSON → fuzzy map to tickers │
│ Output: List[EntityExtraction{asset_id, mention_span, confidence, type}] │
└─────────────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ SENTIMENT & EMOTION ANALYSIS (SentimentEmotionAnalyzer) │
│ • FinBERT (ONNX/PyTorch/Mock) → [neg, neu, pos] probs │
│ • CryptoSentimentCalibrator.calibrate(text, probs) ← LAYER A KEYWORDS │
│ - _get_crypto_signal() uses CRYPTO_BULLISH/BEARISH_KEYWORDS │
│ - WHALE_*_PHRASES weighted 5× │
│ - Word-boundary regex for standard, substring for whale phrases │
│ • Emotion model (DistilRoBERTa) → 6-class emotions │
│ • Heuristic fallback if models unavailable │
│ Output: SentimentScores(polarity, confidence, pos/neg/neu), EmotionScores │
└─────────────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ EVENT CLASSIFICATION (EventClassifier) │
│ • BERT classifier → 12-class event type │
│ • Uses Layer F label schema (EVENT_LABELS) │
└─────────────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ CREDIBILITY SCORING (CredibilityScorer) │
│ • Source base_credibility from Layer D (source_credibility.yaml) │
│ • Cross-source corroboration (in-memory cache) │
│ • Temporal decay (half-life 30 days) │
│ Output: CredibilityScore(composite, components) │
└─────────────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ SIGNAL PROCESSING (SignalProcessor) │
│ • fear_state = f(neg_sentiment, fear_emotion, event_fear) │
│ • greed_state = f(pos_sentiment, greed_emotion, event_greed) │
│ • pump_score = f(greed, joy, pos_events, intensity) │
│ • dump_score = f(fear, anger, neg_events, intensity) │
│ • VelocityComputer → hype_velocity, pub_velocity │
│ • TemporalDecay (Layer E scoring.halflife_minutes) │
│ Output: AssetSentiment per asset │
└─────────────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ CENTROID REFINEMENT (ScoringEngine._refine_with_centroids) ← LAYER E │
│ • Embed combined entity+event text via e5-large-v2 │
│ • Cosine similarity to 6 parameter centroids (Layer E .npy files) │
│ • Blend: 70% signal, 30% centroid │
└─────────────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ AGGREGATION (Aggregator) │
│ • Asset → Industry (Layer C asset_industry_map.yaml) │
│ • Industry → Market │
│ • Decay at each level (asset 30m, industry 60m, market 120m half-life) │
│ Output: SentimentOutput(market, industries, assets) │
└─────────────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ TRADING INTEGRATION │
│ • ACB signals: market_sentiment_state, fear_state, greed_state, │
│ hype_velocity, aggregate_pump_risk │
│ • Book health veto: pump_score > 75 │
│ • AlphaExitV7: dump_score > 70, fear_state > 80 │
└─────────────────────────────────────────────────────────────────────────────┘
```
---
## 4. Consistency & Centralization Analysis
### 4.1 Current State: DISJOINT
| Aspect | Status | Detail |
|--------|--------|--------|
| **Single source of truth** | ❌ No | 6 independent stores with different schemas |
| **Unified ID space** | ❌ No | Keywords (strings), aliases (ticker→ticker), entities (ticker→metadata), sources (source_id), centroids (param name), labels (enum values) |
| **Versioning** | Partial | Git for code (Layer A, F), file mtime for YAML (B, C, D), file mtime for .npy (E) |
| **Audit trail** | Partial | Git for code; DuckDB audit log for source credibility (D); none for centroids (E) |
| **Hot-reload** | Mixed | YAML (B, C, D): yes; Python constants (A, F): no; .npy (E): no |
| **Validation** | Minimal | `vocab_test_cases.json` tests Layer A only; no cross-layer validation |
### 4.2 Duplication & Drift Risks
| Risk | Location | Example |
|------|----------|---------|
| **Keyword ↔ Label drift** | Layer A vs Layer F | `CRYPTO_BULLISH_KEYWORDS` contains "moon" but `LABELING_GUIDELINES` lists "moon" under BULLISH emoji — consistent now, but no enforcement |
| **Alias ↔ Entity drift** | Layer B vs Layer C | `asset_aliases.yaml` has "VITALIK" → "ETH"; `known_entities.yaml` has ETH entry — if one updated without other, resolution breaks |
| **Centroid ↔ Keyword drift** | Layer E vs Layer A | Centroids built from keywords (TODO) but currently random; if keywords change, centroids stale |
| **Source credibility ↔ Event outcome** | Layer D vs Labeling | `false_positive` event outcome adjusts credibility but event labels from Layer F — no automated loop |
---
## 5. Recommendations for Centralization
### 5.1 Immediate (Low Effort)
1. **Single Vocabulary Registry** — Create `config/vocabulary.yaml` with:
```yaml
sentiment_keywords:
bullish: [...]
bearish: [...]
whale_bullish: [...]
whale_bearish: [...]
asset_aliases: {...} # merge Layer B
known_entities: {...} # merge Layer C
source_credibility: [...] # merge Layer D
labeling_schema: # mirror Layer F
sentiment: [BEARISH, BULLISH, NEUTRAL]
events: [...]
emotions: [...]
```
2. **Runtime Loader** — `VocabularyRegistry` class loading YAML + `.npy` centroids, exposing typed accessors.
3. **Validation Tests** — Cross-layer consistency checks:
- Every alias target exists in known_entities
- Every whale phrase keyword appears in corresponding bullish/bearish list
- Centroid rebuild script reads from `vocabulary.yaml` keyword lists
### 5.2 Medium Term
4. **Centroid Auto-Rebuild** — On vocabulary change, trigger centroid recomputation via encoder.
5. **Provenance Tracking** — Add `source: "keyword_list" | "centroid" | "heuristic"` to every score component.
6. **A/B Testing Framework** — Compare keyword-only vs. centroid-only vs. blended scoring.
### 5.3 Long Term
7. **Learned Vocabulary** — Replace hard-coded lists with learned token importance (attention weights, SHAP values) from fine-tuned model.
8. **Semantic Versioning** — `vocabulary.yaml` with `version: "2.1.0"`, migration scripts for schema changes.
---
## 6. File Inventory (Absolute Paths)
| Layer | File | Lines | Size | Last Modified |
|-------|------|-------|------|---------------|
| A | `/mnt/dolphinng5_predict/sentiment_engine/src/sentiment_engine/nlp/sentiment_emotion.py` | ~1,776 | ~68 KB | 2026-07-xx |
| B | `/mnt/dolphinng5_predict/sentiment_engine/config/asset_aliases.yaml` | ~60 | 1.1 KB | 2026-07-xx |
| C | `/mnt/dolphinng5_predict/sentiment_engine/config/known_entities.yaml` | ~55 | 1.8 KB | 2026-07-xx |
| D | `/mnt/dolphinng5_predict/sentiment_engine/config/source_credibility.yaml` | ~70 | 2.9 KB | 2026-07-xx |
| E | `/mnt/dolphinng5_predict/sentiment_engine/config/centroids/*.npy` (6 files) | — | 3.1 KB each | 2026-07-xx |
| F | `/mnt/dolphinng5_predict/sentiment_engine/labeling_pipeline.py` | ~1,000+ | ~48 KB | 2026-07-xx |
| Config | `/mnt/dolphinng5_predict/sentiment_engine/config/settings.yaml` | ~180 | 7.8 KB | 2026-07-xx |
| Test | `/mnt/dolphinng5_predict/sentiment_engine/vocab_test_cases.json` | ~2,000 | 47 KB | 2026-07-xx |
---
## 7. Keyword Counts (Layer A)
| List | Count (approx) | Unique Stems |
|------|----------------|--------------|
| `CRYPTO_BULLISH_KEYWORDS` | 1,200+ | ~400 |
| `CRYPTO_BEARISH_KEYWORDS` | 1,200+ | ~400 |
| `WHALE_BULLISH_PHRASES` | 80 | 80 |
| `WHALE_BEARISH_PHRASES` | 120 | 120 |
| **Total** | **~2,600** | **~1,000** |
*Note: High duplication in lists (many variants: "surge", "surges", "surged", "surgeing", "surgeing").*
---
## 8. Test Coverage (Layer A)
**File:** `vocab_test_cases.json` — 200+ test cases
**Coverage:** Basic positive/negative, whale phrases, compound phrases, edge cases
**Run:** `pytest tests/test_crypto_sentiment_calibrator.py` (if exists) or manual via `labeling_pipeline.py`
---
## 9. Open Questions / TODOs
1. **Centroid building** — `_build_centroids()` currently uses random vectors. Implement keyword-driven centroid construction per `SENTIMENT_SPEC_IMPLEMENT_GUIDE.md`.
2. **Whale phrase matching** — Currently uses simple substring (`phrase in text_lower`). Should use word-boundary regex for consistency with standard keywords.
3. **Compound phrase deduplication** — Lists contain both `"golden.cross"` and `"golden cross"`. Normalize to single representation.
4. **Multi-word n-gram storage** — No explicit n-gram store beyond compound phrases in keyword lists. Consider adding n-gram frequency tracking from corpus.
5. **Language support** — Only English (`supported_languages: ["en"]`). Keyword lists are English-only.
6. **Dynamic keyword weighting** — All keywords equal weight (1). Could learn weights from labeled data.
---
## 10. Appendices
### 10.1 Full Keyword List Excerpt (Layer A)
See `sentiment_emotion.py` lines 200–1400 for complete lists.
### 10.2 Centroid Rebuild Procedure (When Implemented)
```bash
# 1. Update vocabulary.yaml with new keywords
# 2. Run rebuild script
python -m sentiment_engine.scripts.rebuild_centroids
# 3. Verify .npy files updated
# 4. Restart scoring engine
```
### 10.3 Hot-Reload Procedures
| Layer | Command |
|-------|---------|
| B, C, D | `POST /admin/reload-catalogue` (if API exposed) or restart `CatalogueManager` |
| E | Restart `ScoringEngine` (no hot-reload) |
| A, F | Full container rebuild + deploy |
---
**End of Specification**

BIN
sentiment_engine/config/centroids/dump_score.npy Normal file
View File

Binary file not shown.

BIN
sentiment_engine/config/centroids/fear_state.npy Normal file
View File

Binary file not shown.

BIN
sentiment_engine/config/centroids/greed_state.npy Normal file
View File

Binary file not shown.

BIN
sentiment_engine/config/centroids/hype_velocity.npy Normal file
View File

Binary file not shown.

BIN
sentiment_engine/config/centroids/pub_velocity.npy Normal file
View File

Binary file not shown.

BIN
sentiment_engine/config/centroids/pump_score.npy Normal file
View File

Binary file not shown.

2088
sentiment_engine/lexicon_weights.json Normal file
View File

File diff suppressed because it is too large Load Diff

491
sentiment_engine/src/sentiment_engine/nlp/sentiment_emotion.py
View File

@@ -626,26 +626,25 @@ class CryptoSentimentCalibrator:
@classmethod @classmethod
def _get_crypto_signal(cls, text: str) -> str: def _get_crypto_signal(cls, text: str) -> str:
"""Determine crypto sentiment direction from keywords using word boundaries""" """
text_lower = text.lower() Determine crypto sentiment direction using unified weighted lexicon.
# First check whale action phrases (higher priority) The lexicon assigns each term a weight from -100 (extreme bearish) to +100 (extreme bullish).
whale_bullish = sum(1 for phrase in cls.WHALE_BULLISH_PHRASES if phrase in text_lower) Compound/whale terms have higher absolute weights. Matching uses longest-first priority
whale_bearish = sum(1 for phrase in cls.WHALE_BEARISH_PHRASES if phrase in text_lower) with span-based deduplication.
# Standard bullish/bearish keywords This provides the EXPLICIT signal layer. The centroid/cosine layer in ScoringEngine
bullish_score = sum(1 for kw in cls.CRYPTO_BULLISH_KEYWORDS if re.search(r'\b' + re.escape(kw) + r'\b', text_lower)) provides the SEMANTIC refinement layer.
bearish_score = sum(1 for kw in cls.CRYPTO_BEARISH_KEYWORDS if re.search(r'\b' + re.escape(kw) + r'\b', text_lower)) """
cls._load_lexicon()
# Combine whale signals with standard signals (whale actions weighted much higher) score = cls._get_lexicon_score(text)
total_bullish = bullish_score + whale_bullish * 5 # whale actions weighted 5x return cls._lexicon_to_signal(score)
total_bearish = bearish_score + whale_bearish * 5
@classmethod
if total_bullish > total_bearish: def get_lexicon_score(cls, text: str) -> float:
return "bullish" """Public method to get raw lexicon score for integration with centroid layer."""
elif total_bearish > total_bullish: cls._load_lexicon()
return "bearish" return cls._get_lexicon_score(text)
return "neutral"
@classmethod @classmethod
def _get_finbert_signal(cls, probs: np.ndarray) -> str: def _get_finbert_signal(cls, probs: np.ndarray) -> str:
@@ -661,106 +660,97 @@ class CryptoSentimentCalibrator:
@classmethod @classmethod
def calibrate(cls, text: str, probs: np.ndarray) -> np.ndarray: def calibrate(cls, text: str, probs: np.ndarray) -> np.ndarray:
""" """
Calibrate probabilities for crypto semantics. Calibrate FinBERT probabilities using the weighted lexicon score.
Aggressively flips FinBERT's positive/negative when there's a semantic mismatch.
Strongly amplifies signal when both agree. PRINCIPLE: Crypto-specific explicit lexicon WINS over general FinBERT
Makes output clearly directional when crypto has a clear signal. when they disagree. FinBERT is trained on traditional finance where
"surge/rally/pump" = risky/bubble = negative. In crypto, these are bullish.
The lexicon provides a continuous score [-100, 100] representing
explicit keyword evidence with domain-specific weights.
Blending logic:
- If lexicon and FinBERT AGREE on direction: amplify (trust both)
- If lexicon and FinBERT DISAGREE: lexicon wins (crypto-specific > general)
- If lexicon is NEUTRAL (|score| <= 10): trust FinBERT
- If FinBERT is NEUTRAL (|pos-neg| < 0.15): trust lexicon
The centroid/cosine layer in ScoringEngine provides the SEMANTIC
refinement on top of this calibrated output.
""" """
text_lower = text.lower() cls._load_lexicon()
crypto_signal = cls._get_crypto_signal(text) # Get continuous lexicon score [-100, 100]
finbert_signal = cls._get_finbert_signal(probs) lexicon_score = cls._get_lexicon_score(text)
# If crypto says bullish but FinBERT says bearish (or vice versa), force strong directional # FinBERT probabilities: [negative, neutral, positive] = [Bearish, Neutral, Bullish]
if crypto_signal == "bullish" and finbert_signal == "bearish": neg, neu, pos = probs[0], probs[1], probs[2]
# FinBERT thinks negative (bearish), but crypto says bullish finbert_polarity = pos - neg # [-1, 1]
calibrated = np.array([0.05, probs[1], 0.95 - probs[1]]) finbert_confidence = max(probs)
calibrated = calibrated / calibrated.sum()
return calibrated
if crypto_signal == "bearish" and finbert_signal == "bullish": # Lexicon polarity: -1 (bearish) to +1 (bullish)
# FinBERT thinks positive (bullish), but crypto says bearish - FORCE STRONG BEARISH lexicon_polarity = np.clip(lexicon_score / 100.0, -1.0, 1.0)
calibrated = np.array([0.95, probs[1], 0.05]) lexicon_confidence = min(abs(lexicon_score) / 50.0, 1.0) # Full confidence at |50|
calibrated = calibrated / calibrated.sum()
return calibrated
# Also flip if crypto has strong signal but finbert is neutral/weak # Determine agreement
if crypto_signal == "bullish" and finbert_signal == "neutral": finbert_dir = "bullish" if finbert_polarity > 0.1 else "bearish" if finbert_polarity < -0.1 else "neutral"
# Crypto says bullish but FinBERT is uncertain - trust crypto strongly lexicon_dir = "bullish" if lexicon_polarity > 0.1 else "bearish" if lexicon_polarity < -0.1 else "neutral"
calibrated = np.array([0.05, probs[1], 0.95 - probs[1]])
calibrated = calibrated / calibrated.sum()
return calibrated
if crypto_signal == "bearish" and finbert_signal == "neutral": # Case 1: Both agree on direction -> AMPLIFY
# Crypto says bearish but FinBERT is uncertain - trust crypto if finbert_dir == lexicon_dir and finbert_dir != "neutral":
calibrated = np.array([0.95 - probs[1], probs[1], 0.05]) # Weighted average favoring the stronger signal
calibrated = calibrated / calibrated.sum() total_conf = finbert_confidence + lexicon_confidence
return calibrated if total_conf > 0:
w_finbert = finbert_confidence / total_conf
w_lexicon = lexicon_confidence / total_conf
else:
w_finbert = w_lexicon = 0.5
blended_polarity = w_finbert * finbert_polarity + w_lexicon * lexicon_polarity
# Amplify slightly beyond both
blended_polarity = np.clip(blended_polarity * 1.2, -1.0, 1.0)
target_neu = neu * 0.7 # Reduce neutral when both agree
# If crypto is neutral, make output neutral regardless of FinBERT # Case 2: Disagree -> LEXICON WINS (crypto-specific > general finance)
if crypto_signal == "neutral": elif finbert_dir != "neutral" and lexicon_dir != "neutral" and finbert_dir != lexicon_dir:
# Crypto has no clear signal - make output neutral # Lexicon dominates with high weight
calibrated = probs.copy() blended_polarity = 0.85 * lexicon_polarity + 0.15 * finbert_polarity
avg = (probs[0] + probs[2]) / 2 target_neu = 0.15 # Low neutral when strong disagreement resolved
calibrated[0] = calibrated[2] = avg
return calibrated
# Also handle: FinBERT strongly disagrees with neutral crypto # Case 3: Lexicon neutral -> trust FinBERT
if crypto_signal == "neutral" and finbert_signal == "bearish": elif lexicon_dir == "neutral":
# FinBERT says bearish but crypto is neutral - make neutral blended_polarity = finbert_polarity
calibrated = probs.copy() target_neu = neu
avg = (probs[0] + probs[2]) / 2
calibrated[0] = calibrated[2] = avg
return calibrated
if crypto_signal == "neutral" and finbert_signal == "bullish": # Case 4: FinBERT neutral -> trust lexicon
# FinBERT says bullish but crypto is neutral - make neutral elif finbert_dir == "neutral":
calibrated = probs.copy() blended_polarity = lexicon_polarity
avg = (probs[0] + probs[2]) / 2 target_neu = neu * (1 - lexicon_confidence * 0.5)
calibrated[0] = calibrated[2] = avg
return calibrated
# If both agree on direction, strongly amplify the signal (MUST come before weak/uncertain check) # Case 5: One neutral, other directional
if crypto_signal == "bullish" and finbert_signal == "bullish": else:
# Both agree bullish - strongly amplify the signal blended_polarity = lexicon_polarity if lexicon_dir != "neutral" else finbert_polarity
calibrated = probs.copy() target_neu = neu * 0.8
diff = probs[2] - probs[0]
if diff > 0.02: # already bullish
# Strongly amplify the bullish signal
boost = 0.25 * diff # amplify by 25% of the difference
calibrated = probs.copy()
calibrated[2] = min(0.98, calibrated[2] + boost)
calibrated[0] = max(0.02, calibrated[0] - boost)
calibrated = calibrated / calibrated.sum()
return calibrated
if crypto_signal == "bearish" and finbert_signal == "bearish": # Clamp polarity
# Both agree bearish - strongly amplify the signal blended_polarity = np.clip(blended_polarity, -0.98, 0.98)
calibrated = probs.copy() target_neu = np.clip(target_neu, 0.05, 0.9)
diff = probs[0] - probs[2]
if diff > 0.02: # already bearish
# Strongly amplify the bearish signal
boost = 0.5 * diff # amplify by 50% of the difference
calibrated = probs.copy()
calibrated[0] = min(0.98, calibrated[0] + boost)
calibrated[2] = max(0.02, calibrated[2] - boost)
calibrated = calibrated / calibrated.sum()
return calibrated
# If FinBERT is weak/uncertain but crypto has a clear signal, trust crypto # Convert polarity back to probabilities
# Only applies when they DON'T agree (handled above) # pos - neg = blended_polarity
diff = abs(probs[2] - probs[0]) # pos + neg = 1 - target_neu
if crypto_signal != "neutral" and abs(probs[2] - probs[0]) < 0.4: pos_prob = (blended_polarity + 1 - target_neu) / 2
# FinBERT is uncertain but crypto has a signal - trust crypto neg_prob = (1 - target_neu - blended_polarity) / 2
calibrated = probs.copy()
if crypto_signal == "bullish":
calibrated[0], calibrated[2] = probs[2], probs[0]
elif crypto_signal == "bearish":
calibrated[0], calibrated[2] = probs[2], probs[0]
return calibrated
# No clear mismatch - return original # Clamp
return probs pos_prob = max(0.02, min(0.98, pos_prob))
neg_prob = max(0.02, min(0.98, neg_prob))
neu_prob = max(0.05, min(0.95, 1 - pos_prob - neg_prob))
# Renormalize
total = pos_prob + neg_prob + neu_prob
calibrated = np.array([neg_prob / total, neu_prob / total, pos_prob / total])
return calibrated
# Mock classes for testing/fallback # Mock classes for testing/fallback
@@ -1360,29 +1350,119 @@ class CryptoSentimentCalibrator:
"profit taking after 3x rally", "profit taking after pump", "profit taking at top", "profit taking at highs", "profit taking after 3x rally", "profit taking after pump", "profit taking at top", "profit taking at highs",
"profit taking at resistance", "take profit at resistance", "traders take profit", "traders taking profit", "profit taking at resistance", "take profit at resistance", "traders take profit", "traders taking profit",
] ]
# Unified weighted sentiment lexicon (loaded from JSON)
_LEXICON: Dict[str, int] = {}
_LEXICON_LOADED = False
@classmethod
def _load_lexicon(cls) -> None:
"""Load the unified weighted lexicon from JSON file."""
if cls._LEXICON_LOADED:
return
import json
from pathlib import Path
lexicon_path = Path("lexicon_weights.json")
if lexicon_path.exists():
with open(lexicon_path) as f:
cls._LEXICON = json.load(f)
else:
# Fallback: build from class constants (legacy)
cls._build_legacy_lexicon()
cls._LEXICON_LOADED = True
@classmethod
def _build_legacy_lexicon(cls) -> None:
"""Build lexicon from legacy keyword lists (fallback)."""
cls._LEXICON = {}
# Bullish keywords
for kw in cls.CRYPTO_BULLISH_KEYWORDS:
canonical = kw.replace('.', ' ')
if ' ' in kw and '.' not in kw:
cls._LEXICON[canonical] = 30
elif '.' in kw:
cls._LEXICON[canonical] = 20
else:
cls._LEXICON[canonical] = 10
# Bearish keywords
for kw in cls.CRYPTO_BEARISH_KEYWORDS:
canonical = kw.replace('.', ' ')
if ' ' in kw and '.' not in kw:
cls._LEXICON[canonical] = -30
elif '.' in kw:
cls._LEXICON[canonical] = -20
else:
cls._LEXICON[canonical] = -10
# Whale phrases
for kw in cls.WHALE_BULLISH_PHRASES:
canonical = kw.replace('.', ' ')
cls._LEXICON[canonical] = 50
for kw in cls.WHALE_BEARISH_PHRASES:
canonical = kw.replace('.', ' ')
cls._LEXICON[canonical] = -50
@classmethod
def _get_lexicon_score(cls, text: str) -> float:
"""
Compute weighted sentiment score from lexicon.
Returns a score in range [-100, 100] representing net sentiment.
Uses span-based matching with priority: longest matches first.
"""
cls._load_lexicon()
text_lower = text.lower()
# Sort lexicon terms by length (longest first) for priority matching
sorted_terms = sorted(cls._LEXICON.items(), key=lambda x: -len(x[0]))
matched_spans = []
total_score = 0.0
for term, weight in sorted_terms:
# Skip zero-weight terms
if weight == 0:
continue
# Find all non-overlapping matches
for match in re.finditer(r'\b' + re.escape(term) + r'\b', text_lower):
span = (match.start(), match.end())
# Check overlap
if not any(s[0] < span[1] and s[1] > span[0] for s in matched_spans):
matched_spans.append(span)
total_score += weight
# Clamp to [-100, 100]
return max(-100.0, min(100.0, total_score))
@classmethod
def _lexicon_to_signal(cls, score: float) -> str:
"""Convert lexicon score to signal direction."""
if score > 10:
return "bullish"
elif score < -10:
return "bearish"
return "neutral"
@classmethod @classmethod
def _get_crypto_signal(cls, text: str) -> str: def _get_crypto_signal(cls, text: str) -> str:
"""Determine crypto sentiment direction from keywords using word boundaries""" """
text_lower = text.lower() Determine crypto sentiment direction using unified weighted lexicon.
# First check whale action phrases (higher priority) The lexicon assigns each term a weight from -100 (extreme bearish) to +100 (extreme bullish).
whale_bullish = sum(1 for phrase in cls.WHALE_BULLISH_PHRASES if phrase in text_lower) Compound/whale terms have higher absolute weights. Matching uses longest-first priority
whale_bearish = sum(1 for phrase in cls.WHALE_BEARISH_PHRASES if phrase in text_lower) with span-based deduplication.
# Standard bullish/bearish keywords This provides the EXPLICIT signal layer. The centroid/cosine layer in ScoringEngine
bullish_score = sum(1 for kw in cls.CRYPTO_BULLISH_KEYWORDS if re.search(r'\b' + re.escape(kw) + r'\b', text_lower)) provides the SEMANTIC refinement layer.
bearish_score = sum(1 for kw in cls.CRYPTO_BEARISH_KEYWORDS if re.search(r'\b' + re.escape(kw) + r'\b', text_lower)) """
cls._load_lexicon()
# Combine whale signals with standard signals (whale actions weighted much higher) score = cls._get_lexicon_score(text)
total_bullish = bullish_score + whale_bullish * 5 # whale actions weighted 5x return cls._lexicon_to_signal(score)
total_bearish = bearish_score + whale_bearish * 5
@classmethod
if total_bullish > total_bearish: def get_lexicon_score(cls, text: str) -> float:
return "bullish" """Public method to get raw lexicon score for integration with centroid layer."""
elif total_bearish > total_bullish: cls._load_lexicon()
return "bearish" return cls._get_lexicon_score(text)
return "neutral"
@classmethod @classmethod
def _get_finbert_signal(cls, probs: np.ndarray) -> str: def _get_finbert_signal(cls, probs: np.ndarray) -> str:
@@ -1398,106 +1478,97 @@ class CryptoSentimentCalibrator:
@classmethod @classmethod
def calibrate(cls, text: str, probs: np.ndarray) -> np.ndarray: def calibrate(cls, text: str, probs: np.ndarray) -> np.ndarray:
""" """
Calibrate probabilities for crypto semantics. Calibrate FinBERT probabilities using the weighted lexicon score.
Aggressively flips FinBERT's positive/negative when there's a semantic mismatch.
Strongly amplifies signal when both agree. PRINCIPLE: Crypto-specific explicit lexicon WINS over general FinBERT
Makes output clearly directional when crypto has a clear signal. when they disagree. FinBERT is trained on traditional finance where
"surge/rally/pump" = risky/bubble = negative. In crypto, these are bullish.
The lexicon provides a continuous score [-100, 100] representing
explicit keyword evidence with domain-specific weights.
Blending logic:
- If lexicon and FinBERT AGREE on direction: amplify (trust both)
- If lexicon and FinBERT DISAGREE: lexicon wins (crypto-specific > general)
- If lexicon is NEUTRAL (|score| <= 10): trust FinBERT
- If FinBERT is NEUTRAL (|pos-neg| < 0.15): trust lexicon
The centroid/cosine layer in ScoringEngine provides the SEMANTIC
refinement on top of this calibrated output.
""" """
text_lower = text.lower() cls._load_lexicon()
crypto_signal = cls._get_crypto_signal(text) # Get continuous lexicon score [-100, 100]
finbert_signal = cls._get_finbert_signal(probs) lexicon_score = cls._get_lexicon_score(text)
# If crypto says bullish but FinBERT says bearish (or vice versa), force strong directional # FinBERT probabilities: [negative, neutral, positive] = [Bearish, Neutral, Bullish]
if crypto_signal == "bullish" and finbert_signal == "bearish": neg, neu, pos = probs[0], probs[1], probs[2]
# FinBERT thinks negative (bearish), but crypto says bullish finbert_polarity = pos - neg # [-1, 1]
calibrated = np.array([0.05, probs[1], 0.95 - probs[1]]) finbert_confidence = max(probs)
calibrated = calibrated / calibrated.sum()
return calibrated
if crypto_signal == "bearish" and finbert_signal == "bullish": # Lexicon polarity: -1 (bearish) to +1 (bullish)
# FinBERT thinks positive (bullish), but crypto says bearish - FORCE STRONG BEARISH lexicon_polarity = np.clip(lexicon_score / 100.0, -1.0, 1.0)
calibrated = np.array([0.95, probs[1], 0.05]) lexicon_confidence = min(abs(lexicon_score) / 50.0, 1.0) # Full confidence at |50|
calibrated = calibrated / calibrated.sum()
return calibrated
# Also flip if crypto has strong signal but finbert is neutral/weak # Determine agreement
if crypto_signal == "bullish" and finbert_signal == "neutral": finbert_dir = "bullish" if finbert_polarity > 0.1 else "bearish" if finbert_polarity < -0.1 else "neutral"
# Crypto says bullish but FinBERT is uncertain - trust crypto strongly lexicon_dir = "bullish" if lexicon_polarity > 0.1 else "bearish" if lexicon_polarity < -0.1 else "neutral"
calibrated = np.array([0.05, probs[1], 0.95 - probs[1]])
calibrated = calibrated / calibrated.sum()
return calibrated
if crypto_signal == "bearish" and finbert_signal == "neutral": # Case 1: Both agree on direction -> AMPLIFY
# Crypto says bearish but FinBERT is uncertain - trust crypto if finbert_dir == lexicon_dir and finbert_dir != "neutral":
calibrated = np.array([0.95 - probs[1], probs[1], 0.05]) # Weighted average favoring the stronger signal
calibrated = calibrated / calibrated.sum() total_conf = finbert_confidence + lexicon_confidence
return calibrated if total_conf > 0:
w_finbert = finbert_confidence / total_conf
w_lexicon = lexicon_confidence / total_conf
else:
w_finbert = w_lexicon = 0.5
blended_polarity = w_finbert * finbert_polarity + w_lexicon * lexicon_polarity
# Amplify slightly beyond both
blended_polarity = np.clip(blended_polarity * 1.2, -1.0, 1.0)
target_neu = neu * 0.7 # Reduce neutral when both agree
# If crypto is neutral, make output neutral regardless of FinBERT # Case 2: Disagree -> LEXICON WINS (crypto-specific > general finance)
if crypto_signal == "neutral": elif finbert_dir != "neutral" and lexicon_dir != "neutral" and finbert_dir != lexicon_dir:
# Crypto has no clear signal - make output neutral # Lexicon dominates with high weight
calibrated = probs.copy() blended_polarity = 0.85 * lexicon_polarity + 0.15 * finbert_polarity
avg = (probs[0] + probs[2]) / 2 target_neu = 0.15 # Low neutral when strong disagreement resolved
calibrated[0] = calibrated[2] = avg
return calibrated
# Also handle: FinBERT strongly disagrees with neutral crypto # Case 3: Lexicon neutral -> trust FinBERT
if crypto_signal == "neutral" and finbert_signal == "bearish": elif lexicon_dir == "neutral":
# FinBERT says bearish but crypto is neutral - make neutral blended_polarity = finbert_polarity
calibrated = probs.copy() target_neu = neu
avg = (probs[0] + probs[2]) / 2
calibrated[0] = calibrated[2] = avg
return calibrated
if crypto_signal == "neutral" and finbert_signal == "bullish": # Case 4: FinBERT neutral -> trust lexicon
# FinBERT says bullish but crypto is neutral - make neutral elif finbert_dir == "neutral":
calibrated = probs.copy() blended_polarity = lexicon_polarity
avg = (probs[0] + probs[2]) / 2 target_neu = neu * (1 - lexicon_confidence * 0.5)
calibrated[0] = calibrated[2] = avg
return calibrated
# If both agree on direction, strongly amplify the signal (MUST come before weak/uncertain check) # Case 5: One neutral, other directional
if crypto_signal == "bullish" and finbert_signal == "bullish": else:
# Both agree bullish - strongly amplify the signal blended_polarity = lexicon_polarity if lexicon_dir != "neutral" else finbert_polarity
calibrated = probs.copy() target_neu = neu * 0.8
diff = probs[2] - probs[0]
if diff > 0.02: # already bullish
# Strongly amplify the bullish signal
boost = 0.25 * diff # amplify by 25% of the difference
calibrated = probs.copy()
calibrated[2] = min(0.98, calibrated[2] + boost)
calibrated[0] = max(0.02, calibrated[0] - boost)
calibrated = calibrated / calibrated.sum()
return calibrated
if crypto_signal == "bearish" and finbert_signal == "bearish": # Clamp polarity
# Both agree bearish - strongly amplify the signal blended_polarity = np.clip(blended_polarity, -0.98, 0.98)
calibrated = probs.copy() target_neu = np.clip(target_neu, 0.05, 0.9)
diff = probs[0] - probs[2]
if diff > 0.02: # already bearish
# Strongly amplify the bearish signal
boost = 0.5 * diff # amplify by 50% of the difference
calibrated = probs.copy()
calibrated[0] = min(0.98, calibrated[0] + boost)
calibrated[2] = max(0.02, calibrated[2] - boost)
calibrated = calibrated / calibrated.sum()
return calibrated
# If FinBERT is weak/uncertain but crypto has a clear signal, trust crypto # Convert polarity back to probabilities
# Only applies when they DON'T agree (handled above) # pos - neg = blended_polarity
diff = abs(probs[2] - probs[0]) # pos + neg = 1 - target_neu
if crypto_signal != "neutral" and abs(probs[2] - probs[0]) < 0.4: pos_prob = (blended_polarity + 1 - target_neu) / 2
# FinBERT is uncertain but crypto has a signal - trust crypto neg_prob = (1 - target_neu - blended_polarity) / 2
calibrated = probs.copy()
if crypto_signal == "bullish":
calibrated[0], calibrated[2] = probs[2], probs[0]
elif crypto_signal == "bearish":
calibrated[0], calibrated[2] = probs[2], probs[0]
return calibrated
# No clear mismatch - return original # Clamp
return probs pos_prob = max(0.02, min(0.98, pos_prob))
neg_prob = max(0.02, min(0.98, neg_prob))
neu_prob = max(0.05, min(0.95, 1 - pos_prob - neg_prob))
# Renormalize
total = pos_prob + neg_prob + neu_prob
calibrated = np.array([neg_prob / total, neu_prob / total, pos_prob / total])
return calibrated
# ... rest of the file (all other classes remain the same) # ... rest of the file (all other classes remain the same)

27
sentiment_engine/src/sentiment_engine/scoring/engine.py
View File

@@ -99,13 +99,14 @@ class ScoringEngine:
return signal return signal
# Refine each parameter using centroid similarity # Refine each parameter using centroid similarity
# Note: fear_state and greed_state are on AssetSentiment (signal), not VelocityMetrics
params = { params = {
"fear_state": signal.velocity.fear_state, "fear_state": signal.fear_state,
"greed_state": signal.velocity.greed_state, "greed_state": signal.greed_state,
"hype_velocity": signal.velocity.hype_velocity, "hype_velocity": signal.velocity.hype_velocity if signal.velocity else 0.0,
"pub_velocity": signal.velocity.pub_velocity, "pub_velocity": signal.velocity.pub_velocity if signal.velocity else 0.0,
"pump_score": signal.pump_dump.pump_score, "pump_score": signal.pump_dump.pump_score if signal.pump_dump else 0.0,
"dump_score": signal.pump_dump.dump_score, "dump_score": signal.pump_dump.dump_score if signal.pump_dump else 0.0,
} }
for param_name, current_value in params.items(): for param_name, current_value in params.items():
@@ -119,12 +120,14 @@ class ScoringEngine:
params[param_name] = 0.7 * current_value + 0.3 * centroid_score params[param_name] = 0.7 * current_value + 0.3 * centroid_score
# Update signal with refined values # Update signal with refined values
signal.velocity.fear_state = params["fear_state"] signal.fear_state = params["fear_state"]
signal.velocity.greed_state = params["greed_state"] signal.greed_state = params["greed_state"]
signal.velocity.hype_velocity = params["hype_velocity"] if signal.velocity:
signal.velocity.pub_velocity = params["pub_velocity"] signal.velocity.hype_velocity = params["hype_velocity"]
signal.pump_dump.pump_score = params["pump_score"] signal.velocity.pub_velocity = params["pub_velocity"]
signal.pump_dump.dump_score = params["dump_score"] if signal.pump_dump:
signal.pump_dump.pump_score = params["pump_score"]
signal.pump_dump.dump_score = params["dump_score"]
return signal return signal