The following is an implementation of gradient descent made by GPT-4:
```js
class SimpleLinearRegression {
  constructor(lr = 0.01, epochs = 100) {
    this.lr = lr;
    this.epochs = epochs;
    this.m = 0;
    this.b = 0;
  }

  train(x, y) {
    for (let epoch = 0; epoch < this.epochs; epoch++) {
      let dm = 0;
      let db = 0;
      const n = x.length;

      for (let i = 0; i < n; i++) {
        const pred = this.m * x[i] + this.b;
        const error = y[i] - pred;
        dm += -2 * x[i] * error;
        db += -2 * error;
      }

      this.m -= this.lr * (dm / n);
      this.b -= this.lr * (db / n);
    }
  }

  predict(x) {
    return x.map(val => this.m * val + this.b);
  }
}

// Example usage
const x = [1, 2, 3, 4, 5];
const y = [2, 4, 6, 8, 10]; // x times 2

const slr = new SimpleLinearRegression();
slr.train(x, y);
console.log(slr.predict([6, 7, 8])); // Output: [12, 14, 16] (approximately)
```

However, if I increase the training data (the x and y consts)  to arrays with more than 16 elements (from 1 to 17 and 2 to 34, rather than the 1 to 5 and 2 to 10 that it currently is) the predictions suddenly turns negative, why is that?