Source Available

Neurales Source Available Beta

Source Available means this code is available for non-commercial individual, educational, or research purposes.

Any commercial license inquiries are directed to the inbox of jeremy.ruroede@neurales.ai. 

Neurales is a software dedicated to bringing cutting edge Data Science and Machine Learning tools to businesses, researchers, and individuals.

Ease of Use

Neurales allows users to quickly and easily perform complex data science task in minutes and create custom models very easily.

Unique Features

Neurales Analyzes data and models for bias indicators.  It also allows the user to automate the model tuning process through a technique called Neuroevolution. 

Numerous ML Tools

Neurales is a machine learning tool box with many different machine learning tools.

What tools does Neurales contain?

Autoencoder

Autoencoders

An autoencoder is a type of artificial neural network used to learn efficient data codings in an unsupervised manner. The aim of an autoencoder is to learn a representation (encoding) for a set of data, typically for dimensionality reduction, by training the network to ignore signal “noise”. Along with the reduction side, a reconstructing side is learnt, where the autoencoder tries to generate from the reduced encoding a representation as close as possible to its original input, hence its name. Several variants exist to the basic model, with the aim of forcing the learned representations of the input to assume useful properties. Examples are the regularized autoencoders (Sparse, Denoising and Contractive autoencoders), proven effective in learning representations for subsequent classification tasks, and Variational autoencoders, with their recent applications as generative models. Autoencoders are effectively used for solving many applied problems, from face recognition to acquiring the semantic meaning of words.

Read More
Classification

Classification

In statistics, classification is the problem of identifying to which of a set of categories (sub-populations) a new observation belongs, on the basis of a training set of data containing observations (or instances) whose category membership is known. Examples are assigning a given email to the "spam" or "non-spam" class, and assigning a diagnosis to a given patient based on observed characteristics of the patient (sex, blood pressure, presence or absence of certain symptoms, etc.). Classification is an example of pattern recognition. In the terminology of machine learning, classification is considered an instance of supervised learning, i.e., learning where a training set of correctly identified observations is available. The corresponding unsupervised procedure is known as clustering, and involves grouping data into categories based on some measure of inherent similarity or distance.

Read More
Convolutional Neural Network(CNN)

Convolutional Neural Network(CNN)

A convolutional neural network (CNN, or ConvNet) is a class of deep neural networks, most commonly applied to analyzing visual imagery. They are also known as shift invariant or space invariant artificial neural networks (SIANN), based on their shared-weights architecture and translation invariance characteristics. They have applications in image and video recognition, recommender systems, image classification, medical image analysis, natural language processing, and financial time series.

Read More
Generative Adversarial Networks(GAN)

Generative Adversarial Networks(GAN)

A generative adversarial network (GAN) is a class of machine learning frameworks designed by Ian Goodfellow and his colleagues in 2014. Two neural networks contest with each other in a game (in the form of a zero-sum game, where one agent's gain is another agent's loss). Given a training set, this technique learns to generate new data with the same statistics as the training set. For example, a GAN trained on photographs can generate new photographs that look at least superficially authentic to human observers, having many realistic characteristics. Though originally proposed as a form of generative model for unsupervised learning, GANs have also proven useful for semi-supervised learning, fully supervised learning, and reinforcement learning. The core idea of a GANs is based on the "indirect" training through the discriminator, which itself is also being updated dynamically. This basically means that the generator is not trained to minimize the distance to a specific image, but rather to fool the discriminator. This enables the model to learn in an unsupervised manner.

Read More
Genetic Models

Genetic Models

A genetic algorithm (GA) is a metaheuristic inspired by the process of natural selection that belongs to the larger class of evolutionary algorithms (EA). Genetic algorithms are commonly used to generate high-quality solutions to optimization and search problems by relying on biologically inspired operators such as mutation, crossover and selection

Read More
Neural Style Transfer

Neural Style Transfer

Neural Style Transfer (NST) refers to a class of software algorithms that manipulate digital images, or videos, in order to adopt the appearance or visual style of another image. NST algorithms are characterized by their use of deep neural networks for the sake of image transformation. Common uses for NST are the creation of artificial artwork from photographs, for example by transferring the appearance of famous paintings to user-supplied photographs. Several notable mobile apps use NST techniques for this purpose, including DeepArt and Prisma. This method has been used by artists and designers around the globe to develop new artwork based on existent style(s).

Read More
Neuroevolution

Neuroevolution

Neuroevolution, or neuro-evolution, is a form of artificial intelligence that uses evolutionary algorithms to generate artificial neural networks (ANN), parameters, topology and rules. It is most commonly applied in artificial life, general game playing and evolutionary robotics. The main benefit is that neuroevolution can be applied more widely than supervised learning algorithms, which require a syllabus of correct input-output pairs. In contrast, neuroevolution requires only a measure of a network's performance at a task. For example, the outcome of a game (i.e. whether one player won or lost) can be easily measured without providing labeled examples of desired strategies. Neuroevolution is commonly used as part of the reinforcement learning paradigm, and it can be contrasted with conventional deep learning techniques that use gradient descent on a neural network with a fixed topology.

Read More
Object Detection

Object Detection

Object detection deals with detecting instances of semantic objects of a certain class (such as humans, buildings, or cars) in digital images and videos. Well-researched domains of object detection include face detection and pedestrian detection. Object detection has applications in many areas of computer vision, including image retrieval and video surveillance.

Read More
Regression

Regression

In statistical modeling, regression analysis is a set of statistical processes for estimating the relationships between a dependent variable (often called the 'outcome variable') and one or more independent variables (often called 'predictors', 'covariates', or 'features'). The most common form of regression analysis is linear regression, in which a researcher finds the line (or a more complex linear combination) that most closely fits the data according to a specific mathematical criterion. For example, the method of ordinary least squares computes the unique line (or hyperplane) that minimizes the sum of squared distances between the true data and that line (or hyperplane). For specific mathematical reasons (see linear regression), this allows the researcher to estimate the conditional expectation (or population average value) of the dependent variable when the independent variables take on a given set of values. Less common forms of regression use slightly different procedures to estimate alternative location parameters (e.g., quantile regression or Necessary Condition Analysis) or estimate the conditional expectation across a broader collection of non-linear models (e.g., nonparametric regression). Regression analysis is primarily used for two conceptually distinct purposes. First, regression analysis is widely used for prediction and forecasting, where its use has substantial overlap with the field of machine learning. Second, in some situations regression analysis can be used to infer causal relationships between the independent and dependent variables. Importantly, regressions by themselves only reveal relationships between a dependent variable and a collection of independent variables in a fixed dataset. To use regressions for prediction or to infer causal relationships, respectively, a researcher must carefully justify why existing relationships have predictive power for a new context or why a relationship between two variables has a causal interpretation. The latter is especially important when researchers hope to estimate causal relationships using observational data.

Read More

Install Neurales:

This is the installation process to use Neurales. To avoid potential conflicts with other packages it is strongly recommended to use a virtual environment, e.g. python3 virtualenv (see python3 virtualenv documentation).
Step 1:
Install the Python 3, for reference https://www.python.org.

Sudo apt-get install python3
Step 2:
Navigate to the directory of your choice.
cd /path/to/my/directory 
Step 3:
Clone our github repository at https://github.com/Neurales/Neurales_Beta/
git clone https://github.com/Neurales/Neurales_Beta.git
Step 4:
Install dependencies by navigating to Neurales_Beta/neurales- install-scripts/ directory and running the dependency install script for your specified system.
cd /path/to/Neurales_Beta/neurales-install-scripts
then,
sudo python3 linuxamd_ndeps_install.py
Step 5:
Go to the neurales_main directory and start using the tools listed in the "Neurales Tools Section" below.
cd /path/to/Neurales_Beta/neurales_main
then,
python3 "myneuralestool".py

This is the installation process to use Neurales. To avoid potential conflicts with other packages it is strongly recommended to use a virtual environment, e.g. python3 virtualenv (see python3 virtualenv documentation).
Step 1:
Install the Python 3, for reference https://www.python.org.

Sudo brew install python3
Step 2:
Navigate to the directory of your choice.
cd /path/to/my/directory 
Step 3:
Clone our github repository at https://github.com/Neurales/Neurales_Beta/
git clone https://github.com/Neurales/Neurales_Beta.git
Step 4:
Install dependencies by navigating to Neurales_Beta/neurales- install-scripts/ directory and running the dependency install script for your specified system.
cd /path/to/Neurales_Beta/neurales-install-scripts
then,
sudo python3 mac_ndeps_install.py
Step 5:
Go to the neurales_main directory and start using the tools listed in the "Neurales Tools Section" below.
cd /path/to/Neurales_Beta/neurales_main
then,
python3 "myneuralestool".py

This is the installation process to use Neurales. To avoid potential conflicts with other packages it is strongly recommended to use a virtual environment, e.g. python3 virtualenv (see python3 virtualenv documentation).
Step 1:
Install the Python 3, for reference https://www.python.org.

see above link
Step 2:
navigate to the directory of your choice.
cd /path/to/my/directory 
Step 3:
Clone our github repository at https://github.com/Neurales/Neurales_Beta/
git clone https://github.com/Neurales/Neurales_Beta.git
Step 4:
Install dependencies by navigating to Neurales_Beta/neurales- install-scripts/ directory and running the dependency install script for your specified system.
cd /path/to/Neurales_Beta/neurales-install-scripts
then,
python3 windows_ndeps_install.py
Step 5:
Go to the neurales_main directory and start using the tools listed in the "Neurales Tools Section" below.
cd /path/to/Neurales_Beta/neurales_main
then,
python3 "myneuralestool".py

This is the installation process to use Neurales. To avoid potential conflicts with other packages it is strongly recommended to use a virtual environment, e.g. python3 virtualenv (see python3 virtualenv documentation).
Step 1:
Install the Python 3, for reference https://www.python.org.

Sudo apt-get install python3
Step 2:
Navigate to the directory of your choice.
cd /path/to/my/directory 
Step 3:
Clone our github repository at https://github.com/Neurales/Neurales_Beta/
git clone https://github.com/Neurales/Neurales_Beta.git
Step 4:
Install dependencies by navigating to Neurales_Beta/neurales- install-scripts/ directory and running the dependency install script for your specified system.
cd /path/to/Neurales_Beta/neurales-install-scripts
then,
sudo python3 jetson_ndeps_install.py
Step 5:
Go to the neurales_main directory and start using the tools listed in the "Neurales Tools Section" below.
cd /path/to/Neurales_Beta/neurales_main
then,
python3 "myneuralestool".py

Available Neurales Tools

Tutorials Available on our YouTube: Click Here

python3 run_autoencoder.py 

Followed by any number of arguments listed here:
--path: /path/to/my/file
--mode: standard or denoise | default = standard
--num_conv_layers: integer value | default = 3
--channels: integer value | default = 3
--optimizer: sgd, adam, or rmsprop | default = sgd
--lr: float value | default = 0.001(1e-3)
--momentum: float value | default = 0.9
--img_size: integer value | default = 40
--cmap: integer value | default = None
--normalize: True or False | default = True
--epochs: integer value | default = 10
--batch_size: integer value | default = 100
--mean: float value | default = 0.0
--sigma: float value | default = 0.1
--explore: True or False | default = True

python3 run_neurales_main.py 

Followed by any number of arguments listed here:
--path: /path/to/my/file
--mode: clf (classification) or reg (regression) | default = clf
--train_per: float value | default = 0.75
--cross_val: True or False | default = False
--class_hist: True or False | default = True
--model: RF (Random Forest), NB (Naive Bayes), SVM (Support Vector Machine), GB (Gradient Booster), DT (Decision Tree) | default = RF
--feature_scale: True or False | default = True
--feature_analysis: True or False | default = False
--manifold_plot: True or False | default = False
--plot_evr: True or False | default = False
--anomaly_detection: True or False | default = False
--metrics: True or False (compute precision, recall, f1) | default = True
--explore: True or False | default = True

python3 run_neurales_cnn.py 

Followed by any number of arguments listed here:
--train_path: /path/to/my/file
--val_path: /path/to/my/file
--num_conv_layers: integer value | default = 4
--channels: integer value | default = 3
--optimizer: sgd, adam, or rmsprop | default = adam
--lr: float value | default = 0.001(1e-3)
--momentum: float value | default = 0.9
--img_size: integer value | default = 40
--adaptive_type: A(average pooling) or M(max pooling) | default = A
--adaptive_size: integer value | default = 5
--epochs: integer value | default = 5
--batch_size: integer value | default = 10
--batch_norm: True or False | default = False
--dropout: True or False | default = False
--weight_decay: float value | default = 0
--explore: True or False | default = True

python3 run_cnn_neuroevolution.py 

Followed by any number of arguments listed here:
--train_path: /path/to/my/file
--val_path: /path/to/my/file
--generations: integer value | default = 50
--chromosomes: integer value | default =
--elite_frac: float value | default = 0.2
--evolution_mode: crossover or elitist | default = elitist
--num_mutations: integer value | default = 2
--num_parents: integer value | default = 4
--channels: integer value | default = 3
--img_size: integer value | default = 40
--batch_size: integer value | default = 100
--max_epochs: integer value | default = 50
--target_score: float value | default = 0.95
--metric: F1, precision, recall, or accuracy | default = F1
--max_loss_thres: float value | default 1000000
--explore: True or False | default = False

python3 run_genetic_models.py 

Followed by any number of arguments listed here:
--path: /path/to/my/file
--train_per: float value | default = 0.75
--models: GB(gradient boosters) or SVM(support vector machine) | default = GB
--mode: clf(classification) or reg(regression) | default = clf
--generations: integer value | default = 20
--chromosomes: integer value | default = 10
--elite_frac: float value | default = 0.2
--target_score: float value | default = 0.99
--metric: f1, precision, recall, or accuracy | default = f1
--explore: True or False | default = True

python3 run_neurales_gan.py 

Followed by any number of arguments listed here:
--path: /path/to/my/file
--num_conv_layers: integer value | default = 3
--channels: integer value | default = 3
--noise_dim: integer value | default = 3
--img_size: integer value | default = 40
--epochs: integer value | default = 25
--batch_size: integer value | default = 10
--d_opt: sgd, adam, rmsprop | default = sgd
--d_lr: float value | default = 0.0001
--d_mom: float value | default 0.8
--g_opt: sgd, adam, or rmspropr | default = adam
--g_lr: float value | default = 0.001
--g_mom: float value | default = 0.9
--sigma: float value | default = 0.15
--cmap: matplotlib color map | default = None
--normalize: True or False | default = True
--explore: True or False | default = True

python3 run_gan_neuroevolution.py 

Followed by any number of arguments listed here:
--path: /path/to/my/file
--generations: integer value | default = 10
--chromosomes: integer value | default = 10
--elite_frac: float value | default = 0.2
--batch_size: integer value | default = 100
--img_size: integer value | default = 40
--cmap: matplotlib color map | default = None
--normalize: True or False | default = True
--noise_dim: integer value | default = 3
--loss: bce, mse, mae, or kl_div loss | default = bce
--loss_thres: float value | default = 50
--max_epochs: integer value | default = 100

python3 run_object_detection.py 

Followed by any number of arguments listed here:
--img_path: /path/to/my/file | default = ./test_img.jpg
--model: fast_rcnn or mask_rcnn | default = fast_rcnn
--thres: float value | default = 0.9
--text_size: float value | default = 1.5
--plot_conf: True or False | default = False
--box_color: red, green, or blue | default = green
--text_color: red, green, or blue | default = red
--explore: True or False | default = False

python3 run_style_transfer.py 

Followed by any number of arguments listed here:
--content_img: /path/to/my/file | default = ./lana_del_rey.jpg
--style_img: /path/to/my/file | default = ./starry_nights.jpg
--epochs: integer value | default = 400
--style_weight: integer value | default = 10000
--img_size: integer value | default = 400 (note: larger images take significantly more time to train on)
--out_size: integer value | default = 1000 (note: larger images take significantly more time to train on)