cvxrust 0.1.0

A Rust implementation of Disciplined Convex Programming
Documentation 
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

//! LASSO (L1-Regularized Regression) Example
//!
//! This example demonstrates L1-regularized least squares:
//!
//! minimize    ||Ax - b||_2^2 + lambda * ||x||_1
//!
//! L1 regularization encourages sparse solutions.

use cvxrust::prelude::*;

fn main() {
    println!("=== LASSO Regression ===\n");

    // Sparse regression problem: only 3 out of 10 coefficients are important
    #[rustfmt::skip]
    let a = constant_matrix(vec![
        1.0, 0.5, 0.2, 0.8, 0.1, 0.3, 0.4, 0.6, 0.2, 0.1,
        0.8, 0.3, 0.1, 0.9, 0.2, 0.4, 0.3, 0.7, 0.1, 0.2,
        0.6, 0.4, 0.3, 0.7, 0.3, 0.2, 0.5, 0.5, 0.3, 0.3,
        0.9, 0.2, 0.4, 0.6, 0.1, 0.5, 0.2, 0.8, 0.4, 0.1,
        0.7, 0.6, 0.2, 0.5, 0.4, 0.1, 0.6, 0.4, 0.2, 0.4,
        0.5, 0.1, 0.5, 0.4, 0.2, 0.6, 0.1, 0.9, 0.1, 0.2,
    ], 6, 10);

    // True model: y = 3*x1 + 2*x4 + 1*x8 (sparse!)
    let b = constant_vec(vec![4.6, 4.9, 3.7, 4.7, 3.5, 3.2]);

    println!("Problem: Recover sparse coefficients (6 samples, 10 features)");
    println!("True model: y = 3*x1 + 2*x4 + 1*x8\n");

    // Standard least squares
    println!("--- Least Squares (lambda = 0) ---\n");

    let x_ls = variable(10);
    let residual_ls = matmul(&a, &x_ls) - &b;

    let solution_ls = Problem::minimize(sum_squares(&residual_ls))
        .solve()
        .expect("Failed to solve");

    let x_ls_vals = &solution_ls[&x_ls];
    println!("Coefficients:");
    for i in 0..10 {
        println!("  x{}: {:.6}", i + 1, x_ls_vals[(i, 0)]);
    }
    println!("  Objective: {:.6}", solution_ls.value.unwrap());

    // LASSO with moderate regularization
    println!("\n--- LASSO (lambda = 0.5) ---\n");

    let lambda = 0.5;
    let x = variable(10);
    let residual = matmul(&a, &x) - &b;
    let objective = sum_squares(&residual) + constant(lambda) * norm1(&x);

    let solution = Problem::minimize(objective)
        .solve()
        .expect("Failed to solve");

    let x_vals = &solution[&x];
    println!("Coefficients:");
    for i in 0..10 {
        let val = x_vals[(i, 0)];
        let marker = if val.abs() > 0.1 { " <--" } else { "" };
        println!("  x{}: {:.6}{}", i + 1, val, marker);
    }
    println!("  Objective: {:.6}", solution.value.unwrap());

    // LASSO with strong regularization
    println!("\n--- LASSO (lambda = 1.0) ---\n");

    let lambda2 = 1.0;
    let x2 = variable(10);
    let residual2 = matmul(&a, &x2) - &b;
    let objective2 = sum_squares(&residual2) + constant(lambda2) * norm1(&x2);

    let solution2 = Problem::minimize(objective2)
        .solve()
        .expect("Failed to solve");

    let x2_vals = &solution2[&x2];
    println!("Coefficients:");
    for i in 0..10 {
        let val = x2_vals[(i, 0)];
        let marker = if val.abs() > 0.1 { " <--" } else { "" };
        println!("  x{}: {:.6}{}", i + 1, val, marker);
    }
    println!("  Objective: {:.6}", solution2.value.unwrap());
    println!("\nConclusion: LASSO identifies the sparse structure!");
}