Dear Students Student,📚📝✨

To ensure a smooth process of submitting your assignment and guaranteeing that your hard work gets the recognition it deserves, I have prepared a brief guide to help you navigate the submission process for this particular assignment: Non-linear regressor in a microcontroller. Follow these steps to avoid last-minute hassles and ensure your assignment reaches the intended recipients without any glitches.

Note: Please consider that this session must be presented running on the microcontroller (Arduino-uno, MSP430, or other)

1. Main goal 📖✏️:

• Transform your input voltage (using a potentiometer) to distance in centimeters using our implementation script for a non-linear regressor based on ANNs.

2. Nonlinear Relationship 🧮📉:

• Nonlinear regression offers a powerful tool to model complex relationships that can't be captured by a simple straight line. By using polynomial, exponential, logarithmic, or ANNs, nonlinear regression helps us gain a deeper understanding of the underlying patterns in the data.
• Consider the next figure to create a data set of (input, target) -> (voltage, distance) for training your model.
• The larger the data set, the more accurate the model will be.
• Plot your data to be sure you have the correct data instances: (Voltage vs. Distance).

The next point must be covered to present your model successfully:

• Use the TensorFlow framework (a basic guide is provided below)

3. Create the model using TensorFlow 🐍:

• The Dense layer is a fully connected neural network layer, meaning each neuron receives input from all neurons of the previous layer. This is a crucial component in creating neural networks, including those for nonlinear regression or classification tasks.
• Use the Sequential model from Keras (which is part of TensorFlow) to stack layers. Here's an example of a simple neural network with two Dense layers for a nonlinear task; don't forget to change the activation parameter:

    import tensorflow as tf
    from tensorflow.keras.models import Sequential
    from tensorflow.keras.layers import Dense, Input
     
    l0 = Input(shape=(1,), name='l0')
    l1 = Dense(units=20, activation='linear', name='l1')
    l2 = Dense(units=1, activation='linear', name='l2')
    model = Sequential([l0, l1, l2])
  

4. Prepared input data :

• Using StandardScaler from scikit-learn is a common and effective way to scale your data in preparation for machine learning tasks, particularly those involving neural networks. The Standard Scaler in machine learning, as implemented in libraries like scikit-learn, uses a simple formula to standardize features. The formula for the Standard Scaler is as follows:

• Where:

  • z is the standardized value.
  • x is the original value of the feature.
  • μ is the mean of the feature across all samples.
  • σ is the standard deviation of the feature across all samples.

• In Python, it can be implemented as follows

    from sklearn.preprocessing import StandardScaler
    scaler = StandardScaler().fit(input)
    inpScaler = scaler.transform(input) # data ready for ANN
  

5. Train the model 📈🔍:

• Use the mean_squared_error as the loss function and use the loss to determine if your model is ready.

     from tensorflow.keras.optimizers import Adam
     modelo.compile(optimizer=Adam(0.1), loss='mean_squared_error')
     historial = modelo.fit(celsius, fahrenheit, epochs=100, verbose=False)
     plt.xlabel("# Epochs")
     plt.ylabel("MSE")
     plt.plot(historial.history["loss"], '.k')
     plt.show()

  

6. Activation functions 📋🔍:

• In TensorFlow and Keras, you have several activation function options to choose from for your neural network layers. Each activation function serves a different purpose and is suitable for different kinds of tasks. Here's a list of some commonly used activation functions:

• ReLU (Rectified Linear Unit):

  • activation='relu'
  • Most popular choice for hidden layers.
  • Helps with the vanishing gradient problem.
  • Outputs zero for negative inputs and raw input for positive inputs.

• Sigmoid:

  • activation='sigmoid'
  • Squeezes output values into a range between 0 and 1.
  • Commonly used for binary classification tasks.

• Tanh (Hyperbolic Tangent):

  • activation='tanh'
  • Similar to sigmoid but outputs values between -1 and 1.
  • Can be more effective than sigmoid for certain tasks due to its output range.

• Softmax:

  • activation='softmax'
  • Converts the output layer into a probability distribution (each output node's value ranges between 0 and 1, and the sum of all outputs is 1).
  • Ideal for multi-class classification tasks.

• Linear:

  • activation='linear'

  • No transformation is applied (output = input).
  • Commonly used in the output layer for regression tasks.

7. Plot and compare 📉🔍:

• Test your model by passing an array of input data ( linspace ) and plot the results Vs. the real data.
• If your model behaves as expected, go to the next step; otherwise, tune your model(change the number of units, layers, activation function, epochs, and learning rate).

8. ANN implementation 💻0️⃣1️⃣:

• The ANN implementation only needs the Feedforward operation with the last trained weights and bias.
• Thus, extract the weights, bias, and Scaler from your model.

• First, test your matrix operations in Python by doing matrix operations and applying the activation functions
• Second, the feedforward operation in the microcontroller must be implemented.
• This is an example of the Relu function for a microcontroller:

    double relu(double x)
    {
    if(x>=0)
    return x;
    else if(x<0)
    return 0;
    }
  

• Finally, test your ANN on some example instances; if the model yields results similar to the ones in Python, then proceed to implement a loop to read the Arduino's ADC.

Warm regards,

Gerardo Marx

Lecturer