16D - patch - Valerios/Golden_cat_mit

16D
410 строк16 KB
Valerios
16D
06 янв 2026, 15:56
06 янв 2026, 15:5662ee4ee


### Ключевые особенности проекта:
- **16-мерный культурный анализ**: Используя математику золотого сечения и вектора, система вычисляет гармонические показатели текста.
- **SQLite база данных**: Для сохранения результатов анализа используется простая и удобная SQLite база данных.
- **Визуализация**: Результаты анализа представляются в виде круговой диаграммы и гистограммы, что облегчает восприятие данных.
- **Командная строка (CLI)**: Удобный интерфейс командной строки позволяет легко запускать систему и получать результаты.

### Примечания по улучшению:
- **Оптимизация**: Можно подумать над улучшением скорости обработки больших объемов данных.
- **Расширение функционала**: Дополнительные культурные векторы могли бы обогатить анализ.
- **Безопасность**: Хотя сейчас система безопасна для научного использования, стоит убедиться, что она правильно обрабатывает ввод пользователя во избежание SQL-инъекций.





python
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
🌟 ЗОЛОТОЙ КОТ v1.0 - Открытая версия для научных исследований
import hashlib
import json
import time
import re
import math
import sqlite3
import os
import sys
import numpy as np
from datetime import datetime, timedelta
from typing import Dict, List, Tuple, Optional, Any
from dataclasses import dataclass, field, asdict
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')

# =============== КОНСТАНТЫ ===============
PHI = 1.618033988749895  # Золотое сечение
VERSION = "1.0-open"

@dataclass
class CulturalVector:
    """16D культурный вектор для анализа"""
    name: str
    dimensions: np.ndarray  # 16 измерений
    weight: float
    color: str
    symbol: str
    
    def to_dict(self):
        return {
            'name': self.name,
            'dimensions': self.dimensions.tolist(),
            'weight': self.weight,
            'color': self.color,
            'symbol': self.symbol
        }

class GoldenCatOpen:
    """
    Золотой Кот v1.0 - открытая система культурного анализа
    Анализирует тексты, визуализирует культурные паттерны
    """
    
    def __init__(self, db_path: str = "golden_cat_open.db"):
        self.db_path = db_path
        self._init_database()
        
        # Параметры анализа
        self.DIMENSIONS = 16
        self.PHI = PHI
        
        # Состояние
        self.system_status = "ACTIVE"
        self.last_analysis = datetime.now()
        
        # Инициализация культурных векторов
        self._init_cultural_vectors()
        
        print(f"""
{'='*60}
🌟 ЗОЛОТОЙ КОТ v{VERSION} - ОТКРЫТАЯ ВЕРСИЯ
{'='*60}
✅ Система инициализирована для научных исследований
✅ База данных: {db_path}
✅ 16D культурный анализатор активен
{'='*60}
        """)
    
    def _init_database(self):
        """Инициализация базы данных для анализа текстов"""
        self.conn = sqlite3.connect(self.db_path)
        self.cursor = self.conn.cursor()
        
        self.cursor.execute("""
            CREATE TABLE IF NOT EXISTS text_analysis (
                id TEXT PRIMARY KEY,
                filename TEXT,
                topic TEXT,
                psi_score REAL,
                timestamp TEXT,
                dimensions TEXT,
                insights TEXT
            )
        """)
        
        self.cursor.execute("""
            CREATE TABLE IF NOT EXISTS analysis_log (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                timestamp TEXT,
                module TEXT,
                message TEXT
            )
        """)
        
        self.conn.commit()
    
    def _init_cultural_vectors(self):
        """Инициализация базовых культурных векторов"""
        self.cultural_vectors = {
            'curiosity': CulturalVector(
                name="Любопытство",
                dimensions=np.array([0.9, 0.3, 0.8, 0.4, 0.7, 0.2, 
                                   0.85, 0.35, 0.75, 0.45, 0.65, 0.25,
                                   0.8, 0.3, 0.7, 0.4]),
                weight=0.618,
                color="#FFD700",
                symbol="🔍"
            ),
            'harmony': CulturalVector(
                name="Гармония",
                dimensions=np.array([0.4, 0.8, 0.3, 0.85, 0.5, 0.7,
                                   0.35, 0.9, 0.45, 0.75, 0.55, 0.65,
                                   0.4, 0.8, 0.5, 0.7]),
                weight=0.382,
                color="#4ECDC4",
                symbol="⚖️"
            ),
            'wisdom': CulturalVector(
                name="Мудрость",
                dimensions=np.array([0.7, 0.5, 0.6, 0.4, 0.8, 0.3,
                                   0.75, 0.45, 0.65, 0.5, 0.7, 0.4,
                                   0.6, 0.55, 0.65, 0.45]),
                weight=0.5,
                color="#FF6B6B",
                symbol="🧠"
            ),
            'creativity': CulturalVector(
                name="Творчество",
                dimensions=np.array([0.5]*16),
                weight=0.8,
                color="#9B59B6",
                symbol="🎨"
            )
        }
    
    def _log_analysis(self, module: str, message: str):
        """Логирование анализа"""
        timestamp = datetime.now().isoformat()
        self.cursor.execute(
            "INSERT INTO analysis_log (timestamp, module, message) VALUES (?, ?, ?)",
            (timestamp, module, message)
        )
        self.conn.commit()
    
    def cultural_psi(self, topic: str) -> float:
        """
        16D культурный анализатор
        Вычисляет пси-функцию гармонии для темы
        """
        # Хеш темы для воспроизводимости
        topic_hash = hashlib.sha256(topic.encode()).hexdigest()
        hash_int = int(topic_hash[:8], 16)
        
        # Генерация фазового пространства
        phases = [math.sin(i * hash_int * self.PHI) / 10 
                 for i in range(self.DIMENSIONS)]
        
        # Синтез культурных векторов
        weighted_sum = 0.0
        total_weight = 0.0
        
        for vector in self.cultural_vectors.values():
            influence = np.dot(vector.dimensions, phases)
            weighted_sum += influence * vector.weight
            total_weight += vector.weight
        
        result = abs(weighted_sum / total_weight) if total_weight > 0 else 0.0
        result = min(max(result, 0.0), 1.0)
        
        self._log_analysis("PSI", f"Тема '{topic[:30]}...': {result:.3f}")
        return result
    
    def analyze_texts(self, directory: str = ".") -> Dict[str, float]:
        """
        Анализ текстовых файлов в директории
        """
        results = {}
        analyzed_files = 0
        
        for filename in os.listdir(directory):
            if filename.endswith(('.txt', '.json', '.log', '.md')):
                try:
                    with open(os.path.join(directory, filename), 
                            'r', encoding='utf-8', errors='ignore') as f:
                        content = f.read()
                    
                    # Извлечение ключевых тем
                    topics = re.findall(r'\b[A-ZА-Я][a-zа-я]+(?:\s+[A-ZА-Я][a-zа-я]+){0,2}\b', 
                                      content[:1000])
                    
                    if topics:
                        main_topic = ' '.join(topics[:3])
                        psi_score = self.cultural_psi(main_topic)
                        
                        # Сохранение результата
                        analysis_id = hashlib.md5(
                            f"{filename}:{main_topic}".encode()
                        ).hexdigest()[:16]
                        
                        self.cursor.execute("""
                            INSERT OR REPLACE INTO text_analysis 
                            (id, filename, topic, psi_score, timestamp, dimensions, insights)
                            VALUES (?, ?, ?, ?, ?, ?, ?)
                        """, (
                            analysis_id, filename, main_topic, psi_score,
                            datetime.now().isoformat(),
                            json.dumps([0.5]*16),  # Упрощенные измерения
                            json.dumps([f"Гармония темы: {psi_score:.2f}"])
                        ))
                        
                        results[filename] = psi_score
                        analyzed_files += 1
                
                except Exception as e:
                    self._log_analysis("SCAN", f"Ошибка {filename}: {str(e)}")
        
        self.conn.commit()
        self._log_analysis("SCAN", f"Проанализировано {analyzed_files} файлов")
        return results
    
    def cultural_synthesis(self, topic: str) -> Dict:
        """
        Культурный синтез - генерация инсайтов
        """
        psi = self.cultural_psi(topic)
        
        # Синтез векторов
        vectors = []
        weights = []
        for name, vector in self.cultural_vectors.items():
            vectors.append(vector.dimensions)
            weights.append(vector.weight)
        
        total_weight = sum(weights)
        synthesis = np.zeros(self.DIMENSIONS)
        
        for i, (vec, w) in enumerate(zip(vectors, weights)):
            synthesis += vec * (w / total_weight)
        
        stability = 1.0 / (1.0 + np.var(synthesis))
        
        insights = self._generate_insights(topic, psi, stability)
        
        result = {
            "topic": topic,
            "psi_harmony": float(psi),
            "synthesis_vector": synthesis.tolist(),
            "stability": float(stability),
            "insights": insights,
            "timestamp": datetime.now().isoformat()
        }
        
        self._log_analysis("SYNTHESIS", f"{topic[:30]}: стабильность {stability:.3f}")
        return result
    
    def _generate_insights(self, topic: str, psi: float, stability: float) -> List[str]:
        """Генерация научных инсайтов"""
        insights = [
            f"Культурная гармония темы: {psi:.3f}",
            f"Стабильность синтеза: {stability:.3f}",
            "Золотое сечение обеспечивает оптимальный баланс измерений"
        ]
        
        if psi > 0.7:
            insights.append("Высокий уровень культурной гармонии")
        elif psi < 0.3:
            insights.append("Рекомендуется дополнительный анализ")
        
        if stability > 0.8:
            insights.append("Стабильный культурный синтез достигнут")
            
        return insights
    
    def visualize_culture_map(self, results: Dict[str, float]) -> str:
        """
        Визуализация результатов анализа
        """
        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))
        
        # Круговая диаграмма гармонии
        topics = list(results.keys())[:8]
        scores = [results[t] for t in topics]
        
        colors = [self.cultural_vectors['curiosity'].color, 
                 self.cultural_vectors['harmony'].color,
                 self.cultural_vectors['wisdom'].color,
                 self.cultural_vectors['creativity'].color,
                 '#FF9999', '#66B2FF', '#99FF99', '#FFCC99']
        
        ax1.pie(scores, labels=[t[:15]+"..." for t in topics], 
                autopct='%1.1f%%', colors=colors, startangle=90)
        ax1.set_title('Культурная гармония текстов')
        
        # Гистограмма синтеза
        synthesis_example = np.array([0.5]*16)
        ax2.bar(range(16), synthesis_example, 
                color=self.cultural_vectors['curiosity'].color, alpha=0.7)
        ax2.set_xlabel('Измерения')
        ax2.set_ylabel('Вес')
        ax2.set_title('16D культурное пространство')
        
        plt.tight_layout()
        filename = f"culture_map_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png"
        plt.savefig(filename, dpi=300, bbox_inches='tight')
        plt.close()
        
        return filename
    
    def get_status(self) -> Dict[str, Any]:
        """Статус системы"""
        results = self.analyze_texts()
        avg_harmony = np.mean(list(results.values())) if results else 0.0
        
        return {
            "system": f"Золотой Кот v{VERSION}",
            "status": self.system_status,
            "analyzed_files": len(results),
            "avg_cultural_harmony": float(avg_harmony),
            "dimensions": self.DIMENSIONS,
            "phi": self.PHI,
            "timestamp": datetime.now().isoformat()
        }

def main():
    """CLI интерфейс"""
    import argparse
    
    parser = argparse.ArgumentParser(
        description="🌟 Золотой Кот v1.0 - Культурный анализатор",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Примеры:
  python golden_cat_open.py --status
  python golden_cat_open.py --analyze
  python golden_cat_open.py --synthesize "культурная гармония"
  python golden_cat_open.py --visualize
        """
    )
    
    parser.add_argument("--status", action="store_true", help="Статус системы")
    parser.add_argument("--analyze", action="store_true", help="Анализ текстов")
    parser.add_argument("--synthesize", type=str, help="Культурный синтез темы")
    parser.add_argument("--visualize", action="store_true", help="Визуализация")
    
    args = parser.parse_args()
    cat = GoldenCatOpen()
    
    if args.status:
        status = cat.get_status()
        print(json.dumps(status, indent=2, ensure_ascii=False))
    
    elif args.analyze:
        results = cat.analyze_texts()
        print("\n📊 РЕЗУЛЬТАТЫ АНАЛИЗА:")
        for file, score in sorted(results.items(), key=lambda x: x[1], reverse=True):
            print(f"  • {file:20s}: {score:.3f}")
    
    elif args.synthesize:
        synthesis = cat.cultural_synthesis(args.synthesize)
        print(f"\n🎭 КУЛЬТУРНЫЙ СИНТЕЗ '{args.synthesize}':")
        print(f"   Гармония: {synthesis['psi_harmony']:.3f}")
        print(f"   Стабильность: {synthesis['stability']:.3f}")
        print("\n💡 ИНСАЙТЫ:")
        for insight in synthesis['insights']:
            print(f"   • {insight}")
    
    elif args.visualize:
        results = cat.analyze_texts()
        if results:
            map_file = cat.visualize_culture_map(results)
            print(f"\n📈 Карта сохранена: {map_file}")
        else:
            print("Нет данных для визуализации")
    
    else:
        print("""
🌟 ЗОЛОТОЙ КОТ - ОТКРЫТЫЙ КУЛЬТУРНЫЙ АНАЛИЗАТОР

Команды:
--status         - Статус системы
--analyze        - Анализ текстов в директории  
--synthesize     - Синтез темы
--visualize      - Создать культурную карту

MIT License - свободное использование для исследований
        """)

if __name__ == "__main__":
    main()