When exploring machine studying, fans typically encounter quite a few sources centered on high-level languages resembling Python. Nonetheless, for these intrigued by the effectivity and energy of C, the journey takes a particular path. C, referred to as a middle-level language, strikes a steadiness between the simplicity of high-level programming and the strong reminiscence manipulation capabilities of low-level languages. This distinctive mixture makes C a wonderful alternative for implementing machine studying algorithms, offering each precision and management over the computational processes.

But, sensible implementations of machine studying and deep studying algorithms in C might be elusive. On this article, we embark on an thrilling exploration of a easy linear regression mannequin to foretell scholar efficiency based mostly on examine hours utilizing C, strolling via the method step-by-step. This hands-on method won’t solely deepen your understanding but additionally showcase the flexibility and robustness of C within the realm of machine studying.

**Conditions:**

- Fundamental understanding of Programming in C language.
- Fundamental understanding of Algebra.
- Fundamental understanding of Calculus (i.e derivatives)

**Understanding Linear Regression**

Linear regression fashions the connection between two variables, the place one (dependent variable) is predicted from the opposite (impartial variable) via a linear equation. In our case, the equation is represented as `y = wx + b`

, the place:

`y`

is the expected efficiency,`x`

is the variety of examine hours,`w`

is the burden (slope of the road),`b`

is the bias (y-intercept).

**Step-by-Step Implementation**

- Initialization and Information Definition:

`static double X[] = {2, 4, 6, 8}; // Unbiased variable (examine hours)`

static double y[] = {20, 40, 60, 80}; // Dependent variable (efficiency marks)

static double weight = 0;

static double bias = 0;

Right here, `X`

and `y`

characterize our coaching knowledge. `weight`

and `bias`

are parameters initialized to zero, which the mannequin will be taught throughout coaching.

2.Prediction Perform:

`static double* predict(double inputs[], int measurement, double weight, double bias) {`

double* y_predicted = (double*)malloc(measurement * sizeof(double));

// Calculate predictions y = wx + b

for (int i = 0; i < measurement; i++) {

y_predicted[i] = inputs[i] * weight + bias;

}

return y_predicted;

}

This perform computes predicted values (`y_predicted`

) based mostly on present `weight`

and `bias`

.

3. Value Perform:

The fee perform measures the error between the expected values and the precise values. On this case, we use the Imply Squared Error (MSE).

The place:

- J(w,b) is the associated fee.
- m is the variety of knowledge factors.
- y^i is the expected worth for the i-th knowledge level.
- yi is the precise worth for the i-th knowledge level.

`static double price(double inputs[], double labels[], int measurement, double weight, double bias) {`

double loss_value = 0;

double sum_loss = 0;

double* y_predicted = predict(inputs, measurement, weight, bias);for (int i = 0; i < measurement; i++) {

loss_value = (labels[i] - y_predicted[i]) * (labels[i] - y_predicted[i]);

sum_loss += loss_value;

}

free(y_predicted);

return sum_loss / (2 * measurement);

}

Right here, `price`

perform computes the imply squared error, which quantifies the distinction between precise `labels`

and predicted `y_predicted`

.

4. Gradient Capabilities for Optimization:

*Gradients of Weights*

The gradient of the burden is the partial spinoff of the associated fee perform with respect to the burden. It signifies how a lot the burden needs to be adjusted to cut back the associated fee.

*C Code Implementation*

`static double weight_grad(double inputs[], double labels[], int measurement) {`

double grad = 0;

double* y_predicted = predict(inputs, measurement, weight, bias);for (int i = 0; i < measurement; i++) {

grad += (y_predicted[i] - labels[i]) * inputs[i];

}

free(y_predicted);

return grad / measurement;

}

*Gradients of Bias*

The gradient of the bias is the partial spinoff of the associated fee perform with respect to the bias. It signifies how a lot the bias needs to be adjusted to cut back the associated fee.

*C Code Implementation*

`static double bias_grad(double inputs[], double labels[], int measurement) {`

double grad = 0;

double* y_predicted = predict(inputs, measurement, weight, bias);for (int i = 0; i < measurement; i++) {

grad += (y_predicted[i] - labels[i]);

}

free(y_predicted);

return grad / measurement;

}

These features compute gradients (derivatives) of the associated fee perform with respect to `weight`

and `bias`

, essential for updating these parameters throughout coaching.

5. Coaching and Testing:

Throughout coaching, we replace the burden and bias iteratively utilizing the gradients. The training price controls the dimensions of the steps we take in direction of minimizing the associated fee.

Weight replace:

Bias replace:

The place:

- α is the training price.
- ∂J(w,b)/∂w is the gradient of the associated fee perform J(w,b) with respect to the burden w.
- ∂J(w,b)/∂b is the gradient of the associated fee perform J(w,b) with respect to the bias b.

*C Code Implementation*

`void check() {`

int measurement;printf("Let's check our linear modeln");

printf("n");

printf("Enter the dimensions of your knowledge (Variety of knowledge factors):n");

scanf("%d", &measurement);

printf("n");

double inputs[size];

for (int i = 0; i < measurement; i++) {

printf("Enter variety of hour(s) for knowledge : %d n", i + 1);

scanf("%lf", &inputs[i]);

}

printf("n");

double* predictions = predict(inputs, measurement, weight, bias);

printf("Prediction for inputsnn");

for (int i = 0; i < measurement; i++) {

printf("%lf hrs : %lf marks(performances)n", inputs[i], predictions[i]);

}

free(predictions);

}

int most important(void) {

int epoch = 100000;

double learning_rate = 0.0001;

int measurement = sizeof(X) / sizeof(X[0]);

double loss = 0;

double grad_w = 0;

double grad_b = 0;

for (int i = 1; i <= epoch; i++) {

loss = price(X, y, measurement, weight, bias);

grad_w = weight_grad(X, y, measurement);

grad_b = bias_grad(X, y, measurement);

weight = weight - learning_rate * grad_w;

bias = bias - learning_rate * grad_b;

printf("Epoch %d ---- Loss: %lf n", i, loss);

printf("Weight: %lf, Bias: %lf, Grad_W: %lf, Grad_B: %lfn", weight, bias, grad_w, grad_b);

}

printf("n");

printf("Mannequin Loss: %lf n", loss);

printf("Optimum Weight: %lf n", weight);

printf("Optimum Bias: %lf n", bias);

printf("n");

check();

}

This `most important`

perform initializes parameters, trains the mannequin utilizing gradient descent, and evaluates its efficiency utilizing price perform, within the subsequent half we are going to discover different analysis metrics. The check perform is used to check how the mannequin is ready to appropriately predict the efficiency from the hours supplied by person.

Output

**Conclusion:**

Implementing machine studying algorithms in C supplies a deeper understanding of their inside workings and computational effectivity. This instance demonstrates the appliance of linear regression, from knowledge illustration to parameter optimization, in C. By leveraging low-level languages, fans can improve their programming expertise and grasp the foundations of machine studying algorithms extra comprehensively.

By mastering such implementations, builders can leverage the robustness of low-level languages to sort out advanced machine studying challenges successfully.

Hyperlinks:

github: https://github.com/nsomazr/ml-in-c/blob/main/linear-regression/example_linear_model.c