aprender-core 0.29.1

Next-generation machine learning library in pure Rust
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

#![allow(clippy::disallowed_methods)]
//! DataFrame Basics example
//!
//! Demonstrates core DataFrame operations for ML workflows.

use aprender::prelude::*;

fn main() {
    println!("DataFrame Basics Example");
    println!("========================\n");

    // Create a DataFrame with named columns
    let columns = vec![
        (
            "age".to_string(),
            Vector::from_slice(&[25.0, 30.0, 35.0, 40.0, 45.0]),
        ),
        (
            "income".to_string(),
            Vector::from_slice(&[50000.0, 60000.0, 75000.0, 90000.0, 110000.0]),
        ),
        (
            "score".to_string(),
            Vector::from_slice(&[85.0, 90.0, 88.0, 92.0, 95.0]),
        ),
    ];

    let df = DataFrame::new(columns).expect("Failed to create DataFrame");

    // Basic info
    println!("DataFrame Shape: {:?}", df.shape());
    println!("Columns: {:?}\n", df.column_names());

    // Access individual columns
    let ages = df.column("age").expect("Example data should be valid");
    println!("Ages: {:?}", ages.as_slice());
    println!("Mean age: {:.1}\n", ages.mean());

    // Select specific columns
    let selected = df
        .select(&["age", "income"])
        .expect("Example data should be valid");
    println!("Selected columns shape: {:?}", selected.shape());

    // Access rows
    let row = df.row(2).expect("Example data should be valid");
    println!("Row 2: {:?}", row.as_slice());

    // Convert to Matrix for ML algorithms
    let matrix = df.to_matrix();
    println!("\nMatrix shape: {:?}", matrix.shape());
    println!(
        "First row of matrix: [{:.0}, {:.0}, {:.0}]",
        matrix.get(0, 0),
        matrix.get(0, 1),
        matrix.get(0, 2)
    );

    // Descriptive statistics
    println!("\nDescriptive Statistics:");
    println!(
        "{:>10} {:>10} {:>10} {:>10} {:>10}",
        "Column", "Mean", "Std", "Min", "Max"
    );
    println!("{}", "-".repeat(52));

    for stats in df.describe() {
        println!(
            "{:>10} {:>10.1} {:>10.1} {:>10.1} {:>10.1}",
            stats.name, stats.mean, stats.std, stats.min, stats.max
        );
    }

    // Use DataFrame with Linear Regression
    println!("\n--- Linear Regression with DataFrame ---\n");

    // Use age and income to predict score
    let features = df
        .select(&["age", "income"])
        .expect("Example data should be valid");
    let x = features.to_matrix();
    let y = df
        .column("score")
        .expect("Example data should be valid")
        .clone();

    let mut model = LinearRegression::new();
    model.fit(&x, &y).expect("Failed to fit model");

    let predictions = model.predict(&x);
    let r2 = model.score(&x, &y);

    println!("Coefficients:");
    println!("  age coefficient:    {:.6}", model.coefficients()[0]);
    println!("  income coefficient: {:.10}", model.coefficients()[1]);
    println!("  intercept:          {:.4}", model.intercept());
    println!("\nR² Score: {r2:.4}");

    // Predictions
    println!("\nPredictions vs Actual:");
    println!("{:>8} {:>8}", "Actual", "Pred");
    for i in 0..y.len() {
        println!("{:>8.1} {:>8.1}", y[i], predictions[i]);
    }

    println!("\nDataFrame operations completed successfully!");
}