Delete src/drone_esn_training.py with huggingface_hub

src/drone_esn_training.py

@@ -1,138 +0,0 @@
-import numpy as np
-import pickle
-import scipy.sparse
-import os
-from utils import simulate
-
-def train_drone_esn(data_path="drone_dataset.npz"):
-    BASE_DIR = os.path.dirname(os.path.abspath(__file__))
-    if not os.path.isabs(data_path):
-        data_path = os.path.join(BASE_DIR, data_path)
-
-    print("Loading data...")
-    if not os.path.exists(data_path):
-        print(f"{data_path} not found. Run drone_data_collection.py first.")
-        return
-        
-    data = np.load(data_path)
-    states = data['states']     # shape (T, 12) or (T, 20)
-    targets = data['targets']   # shape (T, 4)
-    
-    Nu = states.shape[1]
-    Ny = targets.shape[1]
-    
-    # Let's use 80% for training and 20% for testing
-    split = int(0.8 * len(states))
-    train_u = states[:split]
-    train_label = targets[:split]
-    test_u = states[split:]
-    test_label = targets[split:]
-    
-    print("Loading biological matrices...")
-    try:
-        with open(os.path.join(BASE_DIR, 'W.pkl'), 'rb') as f:
-            W = pickle.load(f)
-        Nx = W.shape[0]
-
-        with open(os.path.join(BASE_DIR, 'W_in.pkl'), 'rb') as f:
-            Win_loaded = pickle.load(f)
-
-        with open(os.path.join(BASE_DIR, 'W_out.pkl'), 'rb') as f:
-            Wout_loaded = pickle.load(f)
-
-        with open(os.path.join(BASE_DIR, 'bias.pkl'), 'rb') as f:
-            bias_loaded = pickle.load(f)
-            
-        print("Creating 50K Bi-Hemispheric Brain...")
-        W = scipy.sparse.block_diag((W, W))
-        Win_loaded = np.concatenate((Win_loaded, Win_loaded))
-        Wout_loaded = np.vstack((Wout_loaded, Wout_loaded))
-        bias_loaded = np.concatenate((bias_loaded, bias_loaded))
-        Nx = W.shape[0] # Update Nx to 50,000
-        
-    except FileNotFoundError:
-        print("Biological matrices (W.pkl, etc.) not found! Falling back to a standard random ESN (Nx=500)...")
-        Nx = 500
-        W = scipy.sparse.random(Nx, Nx, density=0.1, format='csr')
-        Win_loaded = np.random.randn(Nx)
-        Wout_loaded = np.ones((Nx, 1)) # Select all neurons
-        bias_loaded = np.random.randn(Nx, 1) * 0.1
-        
-    # Scale spectral radius to 0.99 (Bypass for 50k as W.pkl is already scaled)
-    if Nx < 25000:
-        try:
-            radius, _ = scipy.sparse.linalg.eigs(W, k=1, which='LM', maxiter=10000, tol=1e-2)
-            radius = abs(np.linalg.norm(radius))
-        except:
-            radius = max(abs(np.linalg.eigvals(W.toarray())))
-        W = W * (0.99 / radius)
-
-    # Ensure Win_loaded and bias_loaded are 1D arrays to prevent sequence assignment error
-    Win_loaded = np.asarray(Win_loaded).flatten()
-    bias_loaded = np.asarray(bias_loaded).flatten()
-
-    # Reshape Win as done in main.ipynb
-    Win_loaded_reshaped = np.zeros((Nu, Nx))
-    for i in range(Nx):
-        row = np.random.choice(Nu)
-        Win_loaded_reshaped[row, i] = Win_loaded[i]
-
-    Win = Win_loaded_reshaped
-    Win = np.vstack((Win, bias_loaded.T)).transpose()
-
-    input_scaling = 0.7
-    Win[:, :-1] = Win[:, :-1] * input_scaling
-
-    Wout_mask = Wout_loaded[:, 0]
-    mask = (Wout_mask == 1)
-
-    print("Simulating reservoir on training data...")
-    step = 0.9  # 1 - leakage rate
-    
-    # Need to simulate washout. Just use initial state (e.g. 100 steps)
-    wash_u = train_u[:100]
-    x0 = np.random.random((Nx, 1))
-    reservoir_wash = simulate(x0, W, Win, np.hstack((wash_u, np.ones((len(wash_u), 1)))), step)
-    
-    x0 = reservoir_wash[:, -1].reshape((Nx, 1))
-    
-    # Train
-    train_u_sim = train_u[100:]
-    train_label_sim = train_label[100:]
-    train_size = len(train_u_sim)
-    
-    # High RAM limit (64GB) allows using maximum precision (Float64)
-    XX = np.zeros((len(np.where(mask)[0]) + 1, len(np.where(mask)[0]) + 1))
-    XY = np.zeros((Ny, len(np.where(mask)[0]) + 1))
-    Yhat = train_label_sim.T
-    
-    XX, XY, reservoir = simulate(x0, W, Win, np.hstack((train_u_sim, np.ones((train_size, 1)))), step, 
-                                 XX, XY, Yhat, building_matrices=True, mask=mask)
-                                 
-    beta = 1e-6
-    print("Performing Ridge Regression (using np.linalg.solve in Float64)...")
-    # np.linalg.solve avoids explicit matrix inversion, making it faster and more stable
-    Wout = np.linalg.solve(XX + beta * np.identity(XX.shape[0]), XY.T).T
-    
-    # Test error
-    X = np.vstack((np.ones((1, train_size)), reservoir.reshape((Nx, train_size))[mask, :]))
-    Y_train = Wout @ X
-    err_train = np.sqrt(np.mean((Y_train - Yhat)**2))
-    print(f"Training RMSE: {err_train}")
-    
-    # Save the trained components
-    print("Saving trained network parameters to W_drone_components.pkl...")
-    components = {
-        'W': W,
-        'Win': Win,
-        'Wout': Wout,
-        'mask': mask,
-        'alpha': step
-    }
-    components_path = os.path.join(BASE_DIR, "W_drone_components.pkl")
-    with open(components_path, "wb") as f:
-        pickle.dump(components, f)
-    print("Training complete!")
-
-if __name__ == "__main__":
-    train_drone_esn()