sw-mlp 1.0.0__py3-none-any.whl

mlp/__init__.py

@@ -0,0 +1,10 @@
+from .neural_network.activation_func import relu, leaky_relu, sigmoid, get_activation_funcs_by_name
+from .neural_network.nnClass import MultiLayerPerceptron
+from .neural_network.nnUtils import *
+
+from .data_process.load_csv import load, preprocess_data
+from .data_process.config_parser import conf_parser
+from .data_process.data_generation import *
+
+
+__all__ = ["MultiLayerPerceptron", relu, leaky_relu, sigmoid, split_dataset, get_activation_funcs_by_name, load, preprocess_data, conf_parser, generate_data_rand]

mlp/__main__.py

@@ -0,0 +1,124 @@
+#!/usr/bin/python3
+
+from numpy import ndarray as array
+import numpy as np
+from mlp.neural_network import MultiLayerPerceptron, get_activation_funcs_by_name
+from mlp.data_process import load, preprocess_data, conf_parser, generate_data_rand
+import sys
+
+
+def print_help() -> None:
+    """Show help messages."""
+
+    print("-----------------------------------------------------------------------------------------------------------------")
+    print("Multilayer perceptron")
+    print("Usage:")
+    print("   uv run -m mlp <option> <config.json> <data.csv> [params.json]")
+    print("Options:")
+    print("  -s:  Split dataset into (train.csv) and (test.csv), no params required")
+    print("  -t:  Train dataset, if params.json is provided, it performs fine tuning.")
+    print("  -p:  Test on a test dataset, if params.json is provided, it performs prediction based on trained model.")
+    print("  --help:  Show help messages.")
+    print("  -More features to come.")
+    print("Note:")
+    print("  There is built in dataset generated by script, use --gen-data1d to replace dataset")
+    print("-----------------------------------------------------------------------------------------------------------------")
+
+
+def mlp_train(nn: MultiLayerPerceptron, conf: dict, inputs: array, truths: array) -> None:
+    """Train a model with traing data and configuration."""
+
+    nn.train(inputs, truths, 
+             conf["max_epoch"], 
+             conf["learning_rate"], 
+             batch_size=conf["batch_size"], 
+             test_ratio=conf["train_ratio"],
+             threshold=conf["threshold"],
+             animation=conf["animation"])
+    nn.save_plots()
+
+
+def mlp_getdata(source: str, conf: dict) -> tuple:
+    """Get data either from input dataset file or from internal options."""
+
+    if source == "--gen-data1d":
+        inputs, truths = generate_data_rand(142, 500, 0.02)
+    else:
+        df = load(source, False)
+        if df is None:
+            sys.exit(1)
+        inputs, truths = preprocess_data(df)
+    return inputs, truths
+
+
+def mlp_splitdata(conf:dict, file:str, ratio:float=0.8) -> None:
+    """Split dataset into 2 parts, training data and test / validation data."""
+
+    df = load(file, conf["index"])
+    if df is None:
+        sys.exit(1)
+    seed = conf["seed"]
+    df_shuffled = df.sample(frac=1, random_state=seed).reset_index(drop=True)
+
+    l = len(df_shuffled)
+    train_data = df_shuffled[:int(ratio * l)]
+    test_data = df_shuffled[int(ratio * l):]
+    print("[Original Data]", df.shape)
+    print("[Train data]", train_data.shape)
+    print("[Test data]", test_data.shape)
+    train_data.to_csv("data/train.csv", index=False, encoding="utf-8")
+    test_data.to_csv("data/test.csv", index=False, encoding="utf-8")
+    print("[Save splited data into (data/train.csv) (data/test.csv)]")
+
+
+def mlp_create_nn(argv:list) -> tuple:
+    """Initialize neural network instance."""
+
+    conf = conf_parser(argv[2])
+    if conf is None:
+        sys.exit(1)
+    np.random.seed(conf["seed"])
+    nn = MultiLayerPerceptron(conf["shape"], get_activation_funcs_by_name(conf["activation_funcs"]), 
+            conf["weights_init"],
+            classification=conf["classification"],
+            loss=conf["loss"])
+    inputs, truths = mlp_getdata(argv[3], conf)
+    if len(argv) == 5:
+        nn.load_weights(argv[4])
+    return nn, inputs, truths, conf
+
+
+def main():
+    try:
+        argv = sys.argv
+        if len(argv) == 1 or ((len(argv) == 2 and argv[1] == "--help")):
+            print_help()
+        elif argv[1] == "-s" and len(argv) == 4:
+            conf = conf_parser(argv[2])
+            if conf is None:
+                sys.exit(1)
+            mlp_splitdata(conf, argv[3], conf["train_ratio"])
+        elif len(argv) == 4 or len(argv) == 5:
+            nn, inputs, truths, conf = mlp_create_nn(argv)
+            if argv[1] == "-t":
+                mlp_train(nn, conf, inputs, truths)
+            elif argv[1] == "-p":
+                nn.test(inputs, truths)
+                # nn.show_test_img(inputs, (28, 28), 8329)
+            else:
+                raise ValueError("Wrong arguments. Try: uv run -m mlp --help")
+        else:
+            raise ValueError("Wrong arguments. Try: uv run -m mlp --help")
+
+    except KeyboardInterrupt as e:
+        print()
+        print("Stopped by user.\033[?25h")
+        sys.exit(1)
+
+    except Exception as e:
+        print("Error:", e)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

mlp/data_process/__init__.py

@@ -0,0 +1,5 @@
+from .load_csv import load, preprocess_data
+from .config_parser import conf_parser
+from .data_generation import *
+
+__all__ = [load, preprocess_data, conf_parser, generate_data_rand]

mlp/data_process/config_parser.py

@@ -0,0 +1,137 @@
+#!/usr/bin/python3
+
+import json
+import sys
+
+
+def wrong_type(conf:dict, field: str, field_type: type, mandatory:bool) -> bool:
+    """Check if a filed in configuration file has right type"""
+    
+    if mandatory and not field in conf:
+        raise ValueError("Missing mandatory field.")
+    if field in conf and isinstance(conf[field], field_type):
+        return False
+    return True
+
+
+def check_arg_type(conf: dict) -> bool:
+    """Check argument type in json configuration file"""
+
+    if wrong_type(conf, "shape", (list,tuple), True):
+        return False
+    elif wrong_type(conf, "activation_funcs", (list,tuple), True):
+        return False
+    elif wrong_type(conf, "weights_init", (list,tuple), True):
+        return False
+    elif wrong_type(conf, "seed", int, True):
+        return False
+    elif wrong_type(conf, "loss", str, True):
+        return False
+    elif wrong_type(conf, "max_epoch", int, True):
+        return False
+    elif wrong_type(conf, "learning_rate", float, True):
+        return False
+    elif wrong_type(conf, "batch_size", int, True):
+        return False
+    elif wrong_type(conf, "classification", bool, True):
+        return False
+    elif wrong_type(conf, "animation", str, True):
+        return False
+    elif wrong_type(conf, "train_ratio", float, True):
+        return False
+    elif wrong_type(conf, "threshold", (bool,float), True):
+        return False
+    elif wrong_type(conf, "index", bool, True):
+        return False
+    return True
+
+
+def valid_net_struct(conf: dict) -> bool:
+    """Check if the neural network has valid structure."""
+
+    shape = conf["shape"]
+    activ_funcs = conf["activation_funcs"]
+    loss = conf["loss"]
+    init = conf["weights_init"]
+
+    if len(shape) < 4:
+        raise ValueError("Minimum layer is 4.")
+    if len(shape) != len(activ_funcs) + 1:
+        raise ValueError("Mismatched shape and activation funcions.")
+    for num in shape:
+        if not isinstance(num, int) or num < 1:
+            raise ValueError("Wrong layer neuron numbers")
+    for act in activ_funcs:
+        if act not in ["relu", "sigmoid", "leaky_relu", "softmax", "none"]:
+            raise ValueError("Wrong activation funcion")
+    if loss not in ["CategoricalCrossEntropy", "MeanSquareError", "BinaryCrossEntropy"]:
+        raise ValueError("Wrong loss function")
+    if (loss == "CategoricalCrossEntropy" or loss == "BinaryCrossEntropy") and activ_funcs[-1] not in  ["sigmoid", "softmax"]:
+        raise ValueError("CrossEntropy loss only accept sigmoid or softmax as last layer activation function")
+    
+    for init_method in init:
+        if not init_method in ["he", "xavier", "zero"]:
+            raise ValueError("Not supported initialization method")
+    if len(init) != len(activ_funcs):
+        raise ValueError("Wrong initialization method numbers")
+    return True
+
+
+def check_arg_value(conf: dict) -> bool:
+    """Check configuration value."""
+
+    if conf["max_epoch"] <= 0:
+        raise ValueError("Max epoch must be positive")
+    if conf["learning_rate"] <= 0:
+        raise ValueError("Learning rate must be positive")
+    if conf["batch_size"] <= 0:
+        raise ValueError("Batch size must be positive")
+    if conf["train_ratio"] <= 0 or conf["train_ratio"] >= 1:
+        raise ValueError("Invalid train ratio")
+    if conf["seed"] <= 0:
+        raise ValueError("Invalid seed.")
+
+
+def is_valid_config(conf: dict) -> bool:
+    """Check if configuration file is correct."""
+
+    if check_arg_type(conf) == False:
+        return False
+    if valid_net_struct(conf) == False:
+        return False
+    check_arg_value(conf)
+    if conf["animation"] != "none" and conf["animation"] != "scatter" and conf["animation"] != "plot":
+        raise ValueError("Wrong animation type")
+    return True
+
+
+def conf_parser(config: str):
+    """Parse the configuration file and check errors."""
+
+    try:
+        with open(config, mode='r') as conf_data:
+            conf = json.load(conf_data)
+        
+        if not is_valid_config(conf):
+            raise ValueError("Wrong config file.")
+
+        print(f"\033[33m-------------------------------------------------------------")
+        print(f"|Load config from file {config}")
+        for (key, value) in conf.items():
+            print("|", key, ":", value)
+        print(f"-------------------------------------------------------------\033[0m")
+        return conf
+
+    except Exception as e:
+        print("Error in configuration:", e)
+        return None
+
+
+def main():
+    conf = conf_parser(sys.argv[1])
+    if conf is None:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

mlp/data_process/data_generation.py

@@ -0,0 +1,29 @@
+#!/usr/bin/python3
+
+import numpy as np
+import math
+
+
+def generate_data_rand(seed, number, noise_scale=0.2):
+    """Generate 1d data with added random noise."""
+
+    np.random.seed(seed)
+    inputs = []
+    truths = []
+    for _ in range(number):
+        x = np.random.rand()
+        inputs.append(np.array([x]))
+        # y = 0.5 * x**2 + 0.3 * np.sin(2 * np.pi * x) + 0.2 * np.exp(-2*x)
+        # y = 2*x
+        # y = x * math.sin(x)
+        # y = x * (1 - math.exp(-x**2))
+        y = math.sin(2*x) * math.exp(-0.1*x) + 0.5 * math.cos(5*x)
+        # y = 0.5 * x**2 + 0.3 * np.sin(2 * np.pi * x)
+        # y = - 0.5 * (x - 0.5)**2 + 0.3 
+        noise = np.random.normal(0, noise_scale)
+        y_noisy = y + noise
+        truths.append(np.array([float(y_noisy)]))
+
+    inputs = np.array(inputs)
+    truths = np.array(truths)
+    return inputs, truths

mlp/data_process/load_csv.py

@@ -0,0 +1,58 @@
+#!/usr/bin/python3
+
+import pandas as pd
+import numpy as np
+import os
+
+
+def convert_to_float(type_name:str):
+    """Convert labels to number."""
+
+    if type_name == "M" or type_name=="1" or type_name == "1.0":
+        return 1.0
+    elif type_name == "B" or type_name=="0" or type_name == "0.0":
+        return 0.0
+    elif isinstance(type_name, int):
+        return type_name
+
+
+def preprocess_data(df: pd.DataFrame):
+    """Preprocess data set to prepare inputs and label truths."""
+
+    df.iloc[:, 0] = df.iloc[:, 0].apply(convert_to_float)
+    data = np.array(df).astype(np.float32)
+    # truths and inputs
+    truths = data[:, 0]           # (N,)
+    inputs = data[:, 1:]          # (N,M)
+    # nomalize col
+    X_min = inputs.min(axis=0)
+    X_max = inputs.max(axis=0)
+    inputs_norm = (inputs - X_min) / (X_max - X_min + 1e-8)
+    truths = truths[:, np.newaxis]     # (N,V)
+    inputs = inputs_norm[:, :]          # (N,M)
+    print("[INPUTS]", inputs.shape)   # (N,M)
+    print("[TRUTHS]", truths.shape)   # (N,V)
+    return inputs, truths
+
+
+def load(path: str, index: bool) -> pd.DataFrame:
+    """Load a csv file and return it's pandas.DataFrame object."""
+
+    try:
+        assert isinstance(path, str), "Wrong file path type."
+        assert os.path.exists(path), "Data file not exists."
+        assert path.endswith(".csv"), "Not csv data."
+
+        if index:
+            df = pd.read_csv(path, index_col=0)
+        else:
+            df = pd.read_csv(path)
+        return df
+
+    except AssertionError as e:
+        print("AssertionError:", e)
+        return None
+
+    except Exception as e:
+        print("Error:", e)
+        return None

mlp/neural_network/__init__.py

@@ -0,0 +1,6 @@
+from .activation_func import relu, leaky_relu, sigmoid, get_activation_funcs_by_name
+from .nnClass import MultiLayerPerceptron
+from .nnUtils import *
+
+
+__all__ = ["MultiLayerPerceptron", relu, leaky_relu, sigmoid, split_dataset, get_activation_funcs_by_name]

mlp/neural_network/activation_func.py

@@ -0,0 +1,62 @@
+#!/usr/bin/python3
+
+from numpy import ndarray as array
+import math
+import numpy as np
+
+
+def relu(value: array):
+	return np.maximum(0, value)
+
+
+def relu_deriv(value: array):
+	return (value > 0).astype(float)
+
+
+def leaky_relu(value: array):
+	return np.maximum(0.02 * value, value)
+
+
+def leaky_relu_deriv(value: array):
+	return np.where(value > 0, 1.0, 0.02)
+
+
+def sigmoid(value: array):
+	return 1.0 / (1.0 + math.e ** -value)
+
+
+def softmax(value: array):
+	exp = np.exp(value - np.max(value, axis=0, keepdims=True))
+	sum = np.sum(exp, axis=0, keepdims=True)
+	soft = exp / sum
+	return soft
+
+
+def sigmoid_deriv(value: array):
+	return value * (1 - value)
+
+
+def activ_deriv(active_func: callable, value:array, deriv_map: dict):
+	"""Get the derivative of an activation function."""
+
+	if active_func is None:
+		return 1
+	if active_func == softmax:
+		raise ValueError("Softmax derivative not implemented")
+	deriv_func = deriv_map[active_func]
+	if deriv_func is None:
+		return 1
+	return deriv_func(value)
+
+
+def get_activation_funcs_by_name(activs):
+	"""Get activation funcs by name, convert string to actual function."""
+
+	activmap = {
+		"relu":relu,
+		"sigmoid": sigmoid,
+		"softmax": softmax,
+		"leaky_relu": leaky_relu,
+		"none": None
+	}
+	return [activmap[a] for a in activs]