https://github.com/anhquoc533/neural-network
A Neural Network framework for building Multi-layer Perceptron model.
https://github.com/anhquoc533/neural-network
artificial-intelligence artificial-neural-networks deep-learning framework machine-learning machine-learning-algorithms neural-network neural-networks numpy python3
Last synced: 3 months ago
JSON representation
A Neural Network framework for building Multi-layer Perceptron model.
- Host: GitHub
- URL: https://github.com/anhquoc533/neural-network
- Owner: AnhQuoc533
- License: mit
- Created: 2022-07-20T19:42:23.000Z (over 3 years ago)
- Default Branch: master
- Last Pushed: 2025-02-18T17:28:59.000Z (12 months ago)
- Last Synced: 2025-03-23T08:04:05.608Z (11 months ago)
- Topics: artificial-intelligence, artificial-neural-networks, deep-learning, framework, machine-learning, machine-learning-algorithms, neural-network, neural-networks, numpy, python3
- Language: Python
- Homepage:
- Size: 23.7 MB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
neural-network
---
**neural-network** is a Python package on TestPyPi that provides a
Multi-Layer Perceptron (MLP) framework built using only [**NumPy**](https://numpy.org/doc/stable/).
The framework supports Gradient Descent, Momentum, RMSProp, and Adam optimizers.
Table of Contents
## Installation
### Dependencies
```
python>=3.8
numpy>=1.22.1
matplotlib>=3.5.1
```
### User installation
You can install neural-network using `pip`:
```
pip install neural-network
```
## Simple Usage
### Designing the Model Architecture
To define your MLP model, you need to specify the number of layers and the number of neurons in each one. \
Unless you want to manually set up the parameters, the size of the input layer is not needed, as it will be automatically determined in the initial training process.
```python
from neural_network import NeuralNetwork
model = NeuralNetwork(neurons=[64, 120, 1])
```
In this example, we have a four-layer neural network containing auto-defined input neurons,
first hidden layer with 64 neurons, second hidden layer with 120 neurons, and one output neuron.
### Training the Model
To train the model, you need to provide the input data and the corresponding target (or label) data.
```python
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([[0], [1], [1], [0]])
model.fit(X, y, epochs=1000, learning_rate=0.1, optimizer='adam')
```
When training the model without setting the activation functions or/and the loss functions, the framework will automatically do the job for you. It will initialize the parameters and the functions according to the type of model (regression or classification) and its architecture.
### Making predictions
Once the model has been trained, you can use it to make predictions by simple call `predict` method.
```python
predictions = model.predict(X)
```
## Beyond the Framework
Apart from the neural network framework, the package also provides:
### Activation functions
Sigmoid function
sigmoid()
Hyperbolic tangent function
tanh()
Rectified linear unit
relu()
Leaky Rectified linear unit
leaky_relu()
Softmax function
softmax()
Gaussian error linear unit
gelu()
All above functions have 2 parameters:
* `x`: The input values. Even though some functions can accept numeric primitive data type,
it is advised to use NumPy array.
* `derivative`: A boolean value indicating whether the function computes the derivative on the input `x`. Default is False.
### Loss functions
Logistic loss function
log_loss()
Cross-entropy loss function
cross_entropy_loss()
Quadratic loss function
quadratic_loss()
All above functions have 3 parameters:
* `y_pred`: Predicted labels. It must be a 2D NumPy array and have the same size as `y_true`.
* `y_true`: True labels. It must be a 2D NumPy array and have the same size as `y_pred`.
* `derivative`: A boolean value indicating whether the function computes the derivative. Default is False.
### 2D Decision Boundary
This utility function is used for illustrative purpose. It takes a trained binary classification model, a 2D NumPy input data with 2 attributes, and the corresponding binary label data as input. The function then will plot a 2D decision boundary based on the prediction of the model. \
The input model is not necessarily an instance of **NeuralNetwork**, but it must have `predict`
method that accepts a 2D NumPy array as input.
```python
plot_decision_boundary(model, train_x, train_y)
```
## License
This project has MIT License, as found in the [LICENSE](LICENSE) file.