In MIPS architecture, what is the difference between a register which is preserved and non preserved on calls?

I do understand that preserved on call registers are automatically reverted back to their original value once the function is over.

I tried to undertand how preserved on call registers work. It makes sense to use $s0-$s7 in the loops to store the intermediary results and memory addresses. But when it comes to $ra, I am so confused...

Call preserved registers are not automatically reverted upon function return — they are manually restored by the exit code (called epilogue) of any function that modifies them.  This restoration is mandated by the calling convention, and every function follows the rules set forth by the calling convention (or else program is buggy and may work or may crash).

There is no hardware difference in preserved vs. scratch registers — any differences are due to convention and register usage models supported by it.

$ra is a parameter supplied by the caller that a function uses to return to the right call site, since a function can be invoked from different call sites.  These day we would describe the contents of parameter $ra as a return address (not to be confused with function return value); in older parlance, this was called linkage.  Thejal instruction implicitly targets the $ra register with the return address of the next instruction after the jal.  You don't necessarily have to use jal to call a function, but you do need to need to pass a valid return address in that register.  (Using the given instructions as intended for call and return helps with hardware branch prediction, when present, though.)

If your function makes a call, this will involve a total of two return addresses — namely this function's own return address, and the called function's for return to this function.  Calling will necessarily repurpose the $ra register for this call.  This repurposing will wipe out the previous value held in that register, which is needed to get back to the caller, so a function that makes a function call has to consider its own return address, and save and restore that for its own benefit and usage.  Callers don't rely on $ra being restored.

$ra restoration often appears along side $s register restoration, making $ra appear somewhat like a call-preserved register; however, it is used directly in the epilogue itself to return to the caller rather than being restored for the caller — its last use is within the function itself, whereas by contrast $s registers are being restored for some callers' benefit.

By contrast, the $s registers are preserved for some caller's benefit.  We don't know which caller has what values in these registers, but we don't have to as long as we preserve the values in those registers — either by not using them, or by save & restore for the ones used.