iron_learn 0.5.0

High-performance pure Rust ML library with GPU-accelerated gradient descent. Supports tensors, complex numbers, linear/logistic regression, and CUDA optimization.
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
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

import numpy as np
from sklearn.linear_model import LinearRegression, LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error, accuracy_score
import time
import json

def load_data(file_path):
    with open(file_path, "r") as f:
        data = json.load(f)
    return data

def run_linear_regression():
    print("\nLinear Regression")
    print("-" * 20)
    
    # Load data from the same JSON file
    data = load_data("data.json")
    x_data = np.array(data["linear"]["x"])
    y = np.array(data["linear"]["y"])
    
    # Reshape X into a 2D array with 6 features
    m = data["linear"]["m"]
    n = data["linear"]["n"]
    X = x_data.reshape(m, n)
    
    print(f"Number of examples (m): {m}")
    print(f"Number of features (n): {n}")
    print(f"Total X values length: {m * n}")
    print(f"Total Y values length: {len(y)}")
    
    # Load test data
    x_test_data = np.array(data["linear"]["x_test"])
    y_test = np.array(data["linear"]["y_test"])
    X_test = x_test_data.reshape(-1, n)
    
    # Scale features
    scaler = StandardScaler()
    X_scaled = scaler.fit_transform(X)
    X_test_scaled = scaler.transform(X_test)
    
    # Train model
    start_time = time.time()
    model = LinearRegression()
    model.fit(X_scaled, y)
    
    # Print training time
    elapsed = time.time() - start_time
    print(f"Elapsed: {elapsed:.2f}s")
    
    # Print weights (including bias)
    weights = np.concatenate(([model.intercept_], model.coef_)).reshape(-1, 1)
    print(f"Final weights: {weights.tolist()}")
    
    # Make predictions
    y_pred = model.predict(X_test_scaled)
    print(f"\nPredictions: {y_pred.reshape(-1, 1).tolist()[:10]} ...")
    
    # Calculate metrics
    mse = mean_squared_error(y_test, y_pred)
    rmse = np.sqrt(mse)
    print(f"\nResults:")
    print(f"Total test samples: {len(y_test)}")
    print(f"Mean Squared Error: {mse:.4f}")
    print(f"Root MSE: {rmse:.4f}")

def run_logistic_regression():
    print("\nLogistic Regression")
    print("-" * 20)
    
    # Load data
    data = load_data("data.json")
    x_data = np.array(data["logistic"]["x"])
    y = np.array(data["logistic"]["y"])
    
    # Reshape X into a 2D array with 2 features
    m = data["logistic"]["m"]
    n = data["logistic"]["n"]
    X = x_data.reshape(m, n)
    
    # Load test data
    x_test_data = np.array(data["logistic"]["x_test"])
    y_test = np.array(data["logistic"]["y_test"])
    X_test = x_test_data.reshape(-1, n)
    
    print(f"Number of examples (m): {m}")
    print(f"Number of features (n): {n}")
    print(f"Total X values length: {m * n}")
    print(f"Total Y values length: {len(y)}")
    
    # Scale features
    scaler = StandardScaler()
    X_scaled = scaler.fit_transform(X)
    X_test_scaled = scaler.transform(X_test)
    
    # Train model
    start_time = time.time()
    model = LogisticRegression(random_state=42)
    model.fit(X_scaled, y)
    
    # Print training time
    elapsed = time.time() - start_time
    print(f"Elapsed: {elapsed:.2f}s")
    
    # Print weights (including bias)
    weights = np.concatenate(([model.intercept_[0]], model.coef_[0])).reshape(-1, 1)
    print(f"Final weights: {weights.tolist()}")
    
    # Make predictions
    y_pred = model.predict(X_test_scaled)
    print(f"\nPredictions: {y_pred.tolist()}")
    
    # Calculate accuracy
    accuracy = accuracy_score(y_test, y_pred)
    print(f"\nResults:")
    print(f"Total samples: {len(y_test)}")
    print(f"Correct predictions: {sum(y_pred == y_test)}")
    print(f"Accuracy: {accuracy * 100:.2f}%")

if __name__ == "__main__":
    run_linear_regression()
    run_logistic_regression()