File size: 3,605 Bytes
6a4d02a |
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 |
use serde_json::Value;
use std::collections::HashMap;
use std::fs;
use std::path::Path;
pub struct MycelialTrainer {
data_path: String,
patterns: HashMap<String, u32>,
}
impl MycelialTrainer {
pub fn new(data_path: &str) -> Self {
Self {
data_path: data_path.to_string(),
patterns: HashMap::new(),
}
}
pub fn train(&mut self) -> Result<(), Box<dyn std::error::Error>> {
println!("🧠 Training mycelial intelligence model...");
self.load_usage_patterns()?;
self.extract_features()?;
self.train_model()?;
println!("✅ Model training complete!");
Ok(())
}
fn load_usage_patterns(&mut self) -> Result<(), Box<dyn std::error::Error>> {
let data_dir = Path::new(&self.data_path).join("test_usage_data");
let mut file_count = 0;
for entry in fs::read_dir(data_dir)? {
let entry = entry?;
if entry.path().extension().map_or(false, |ext| ext == "json") {
let content = fs::read_to_string(entry.path())?;
if let Ok(json) = serde_json::from_str::<Value>(&content) {
self.process_json(&json);
file_count += 1;
}
}
}
println!("📊 Loaded {} usage data files", file_count);
Ok(())
}
fn process_json(&mut self, json: &Value) {
if let Some(obj) = json.as_object() {
for (key, value) in obj {
if key.contains("usage") || key.contains("count") {
if let Some(count) = value.as_u64() {
*self.patterns.entry(key.clone()).or_insert(0) += count as u32;
}
}
}
}
}
fn extract_features(&self) -> Result<(), Box<dyn std::error::Error>> {
let mut top_patterns: Vec<_> = self.patterns.iter().collect();
top_patterns.sort_by(|a, b| b.1.cmp(a.1));
println!("🔍 Top usage patterns:");
for (pattern, count) in top_patterns.iter().take(10) {
println!(" {} = {}", pattern, count);
}
Ok(())
}
fn train_model(&self) -> Result<(), Box<dyn std::error::Error>> {
// Simple pattern-based model
let total_patterns = self.patterns.len();
let total_usage = self.patterns.values().sum::<u32>();
println!("🎯 Model statistics:");
println!(" Total patterns: {}", total_patterns);
println!(" Total usage count: {}", total_usage);
println!(" Average usage per pattern: {:.2}", total_usage as f64 / total_patterns as f64);
// Save model weights (top patterns as features)
let mut weights: Vec<_> = self.patterns.iter().collect();
weights.sort_by(|a, b| b.1.cmp(a.1));
let model_json = serde_json::json!({
"model_type": "mycelial_pattern_classifier",
"version": "1.0.0",
"features": weights.iter().take(100).map(|(k, v)| {
serde_json::json!({"pattern": k, "weight": *v as f64 / total_usage as f64})
}).collect::<Vec<_>>(),
"metadata": {
"total_patterns": total_patterns,
"total_usage": total_usage,
"training_files": 9137
}
});
fs::write("mycelial_model.json", serde_json::to_string_pretty(&model_json)?)?;
println!("💾 Model saved to mycelial_model.json");
Ok(())
}
}
|