File size: 6,682 Bytes
8d3de43 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 | #!/usr/bin/env python3
"""
Image Generation Learning System
Learns from user feedback to generate better images over time
"""
import json
import time
from pathlib import Path
from typing import Dict, List, Optional, Tuple
import os
class ImageLearningSystem:
"""
Self-learning image generation system
Remembers what users liked and improves accordingly
"""
def __init__(self, data_dir: str = "noahski_data"):
self.data_dir = Path(data_dir)
self.data_dir.mkdir(parents=True, exist_ok=True)
self.learning_file = self.data_dir / "image_learning_data.json"
self.feedback_file = self.data_dir / "image_feedback.json"
self.learning_data = self._load_learning_data()
self.feedback_history = self._load_feedback()
def _load_learning_data(self) -> Dict:
"""Load learning data"""
if self.learning_file.exists():
try:
with open(self.learning_file, 'r') as f:
return json.load(f)
except:
return self._default_learning_data()
return self._default_learning_data()
def _default_learning_data(self) -> Dict:
"""Default learning parameters"""
return {
'successful_prompts': {},
'parameter_scores': {
'shading_intensity': 0.8,
'texture_density': 0.6,
'color_saturation': 0.85,
'detail_level': 0.7,
'lighting_strength': 0.75
},
'learned_colors': {},
'total_feedback': 0,
'positive_count': 0,
'improvement_rate': 1.0
}
def _load_feedback(self) -> List:
"""Load feedback history"""
if self.feedback_file.exists():
try:
with open(self.feedback_file, 'r') as f:
return json.load(f)
except:
return []
return []
def record_feedback(self, prompt: str, feedback_type: str, params: Dict = None) -> None:
"""Record user feedback for learning"""
feedback = {
'timestamp': time.time(),
'prompt': prompt,
'type': feedback_type, # 'positive' or 'negative'
'params': params or {}
}
self.feedback_history.append(feedback)
# Update learning data
self.learning_data['total_feedback'] += 1
if feedback_type == 'positive':
self.learning_data['positive_count'] += 1
# Update prompt success rate
if prompt not in self.learning_data['successful_prompts']:
self.learning_data['successful_prompts'][prompt] = {'positive': 0, 'total': 0}
self.learning_data['successful_prompts'][prompt]['total'] += 1
if feedback_type == 'positive':
self.learning_data['successful_prompts'][prompt]['positive'] += 1
# Calculate improvement metrics
if self.learning_data['total_feedback'] > 0:
success_rate = self.learning_data['positive_count'] / self.learning_data['total_feedback']
self.learning_data['improvement_rate'] = min(1.2, 0.8 + success_rate * 0.4)
self._save_learning_data()
self._save_feedback()
def get_improved_parameters(self, base_params: Dict) -> Dict:
"""Get improved generation parameters based on learning"""
improved = base_params.copy()
# Apply learned improvements
for param, value in self.learning_data['parameter_scores'].items():
if param in improved:
# Blend base with learned value
blend = 0.6 # 60% learned, 40% original
improved[param] = base_params[param] * (1 - blend) + value * blend
# Apply improvement rate
rate = self.learning_data['improvement_rate']
for param in ['shading_intensity', 'texture_density', 'color_saturation']:
if param in improved:
improved[param] = min(1.0, improved[param] * rate)
return improved
def get_success_rate(self, prompt: str = None) -> float:
"""Get success rate for a prompt or overall"""
if prompt and prompt in self.learning_data['successful_prompts']:
data = self.learning_data['successful_prompts'][prompt]
if data['total'] > 0:
return data['positive'] / data['total']
if self.learning_data['total_feedback'] > 0:
return self.learning_data['positive_count'] / self.learning_data['total_feedback']
return 0.5 # Default neutral
def _save_learning_data(self) -> None:
"""Save learning data"""
try:
with open(self.learning_file, 'w') as f:
json.dump(self.learning_data, f, indent=2)
except:
pass
def _save_feedback(self) -> None:
"""Save feedback history"""
try:
with open(self.feedback_file, 'w') as f:
json.dump(self.feedback_history, f, indent=2)
except:
pass
def get_stats(self) -> Dict:
"""Get learning stats"""
return {
'total_feedback': self.learning_data['total_feedback'],
'positive_count': self.learning_data['positive_count'],
'success_rate': self.get_success_rate(),
'improvement_rate': self.learning_data['improvement_rate']
}
# Global instance
_learning_system = None
def get_learning_system() -> ImageLearningSystem:
"""Get global learning system instance"""
global _learning_system
if _learning_system is None:
_learning_system = ImageLearningSystem()
return _learning_system
def get_improved_generation_params(base_params: Dict = None) -> Dict:
"""Get generation parameters improved by learning"""
if base_params is None:
base_params = {
'shading_intensity': 0.8,
'texture_density': 0.6,
'color_saturation': 0.85,
'detail_level': 0.7,
'lighting_strength': 0.75
}
system = get_learning_system()
return system.get_improved_parameters(base_params)
def record_image_feedback(prompt: str, feedback_type: str) -> None:
"""Record feedback for an image"""
system = get_learning_system()
system.record_feedback(prompt, feedback_type)
|