> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-8a08bda2.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

> Esta função implementa regressão linear estocástica. Suporta parâmetros personalizados para taxa de aprendizado, coeficiente de regularização L2, tamanho do mini-batch e alguns métodos de atualização dos pesos (Adam, SGD simples, Momentum, Nesterov.)

# stochasticLinearRegression

<div id="stochasticLinearRegression">
  ## stochasticLinearRegression
</div>

Introduzido em: v20.1.0

Esta função implementa regressão linear estocástica.
Ela oferece suporte a parâmetros personalizados para:

* taxa de aprendizado
* coeficiente de regularização L2
* tamanho do mini-batch

Ela também inclui alguns métodos para atualizar os pesos:

* Adam (usado por padrão)
* SGD simples
* Momentum
* Nesterov

**Uso**

A função é usada em duas etapas: ajustar o modelo e fazer previsões com novos dados.

1. Ajuste

Para o ajuste, pode-se usar uma consulta como esta:

```sql theme={null}
CREATE TABLE IF NOT EXISTS train_data
(
    param1 Float64,
    param2 Float64,
    target Float64
) ENGINE = Memory;

CREATE TABLE your_model ENGINE = Memory AS SELECT
stochasticLinearRegressionState(0.1, 0.0, 5, 'SGD')(target, x1, x2)
AS state FROM train_data;
```

Aqui, também precisamos inserir dados na tabela `train_data`.
O número de parâmetros não é fixo; ele depende apenas do número de argumentos passados para `linearRegressionState`.
Todos eles devem ser valores numéricos.
Observe que a coluna com o valor-alvo (que queremos aprender a prever) é inserida como o primeiro argumento.

2. Predição

Após salvar um estado na tabela, podemos usá-lo várias vezes para predição ou até mesmo mesclá-lo com outros estados e criar modelos novos, ainda melhores.

```sql theme={null}
WITH (SELECT state FROM your_model) AS model SELECT
evalMLMethod(model, x1, x2) FROM test_data
```

A consulta retornará uma coluna de valores previstos.
Observe que o primeiro argumento de `evalMLMethod` é um objeto `AggregateFunctionState`; os demais são colunas de atributos.

`test_data` é uma tabela como `train_data`, mas pode não conter o valor-alvo.

**Observações**

1. Para mesclar dois modelos, o usuário pode criar a seguinte consulta:

```sq; theme={null}
SELECT state1 + state2 FROM your_models
```

onde a tabela `your_models` contém os dois modelos.
Esta consulta retornará um novo objeto `AggregateFunctionState`.

2. Você pode recuperar os pesos do modelo criado para uso próprio sem salvar o modelo, se nenhum combinador `-State` for usado.

```sql theme={null}
SELECT stochasticLinearRegression(0.01)(target, param1, param2)
FROM train_data
```

Uma consulta como esta ajustará o modelo e retornará seus pesos — os primeiros são os pesos, que correspondem aos parâmetros do modelo; o último é o viés.
Assim, no exemplo acima, a consulta retornará uma coluna com 3 valores.

**Sintaxe**

```sql theme={null}
stochasticLinearRegression([learning_rate, l2_regularization_coef, mini_batch_size, method])(target, x1, x2, ...)
```

**Argumentos**

* `learning_rate` — O coeficiente do tamanho do passo quando é executada uma etapa de descida do gradiente. Uma taxa de aprendizado muito alta pode fazer com que os pesos do modelo se tornem infinitos. O padrão é `0.00001`. [`Float64`](/pt-BR/reference/data-types/float)
* `l2_regularization_coef` — Coeficiente de regularização L2, que pode ajudar a evitar sobreajuste. O padrão é `0.1`. [`Float64`](/pt-BR/reference/data-types/float)
* `mini_batch_size` — Define o número de elementos cujos gradientes serão calculados e somados para executar um passo de descida do gradiente. A descida estocástica pura usa um único elemento; no entanto, usar batches pequenos (cerca de 10 elementos) torna os passos do gradiente mais estáveis. O padrão é `15`. [`UInt64`](/pt-BR/reference/data-types/int-uint)
* `method` — Método para atualizar os pesos: `Adam` (padrão), `SGD`, `Momentum`, `Nesterov`. `Momentum` e `Nesterov` exigem um pouco mais de processamento e memória, mas acabam sendo úteis em termos de velocidade de convergência e estabilidade dos métodos de gradiente estocástico. [`const String`](/pt-BR/reference/data-types/string)
* `target` — Valor-alvo (variável dependente) que se deseja prever. Deve ser numérico. [`Float*`](/pt-BR/reference/data-types/float)
* `x1, x2, ...` — Valores das features (variáveis independentes). Todos devem ser numéricos. [`Float*`](/pt-BR/reference/data-types/float)

**Valor retornado**

Retorna os pesos treinados do modelo de regressão linear. Os primeiros valores correspondem aos parâmetros do modelo; o último é o viés. Use `evalMLMethod` para fazer previsões. [`Array(Float64)`](/pt-BR/reference/data-types/array)

**Exemplos**

**Treinamento de um modelo**

```sql title=Query theme={null}
CREATE TABLE your_model
ENGINE = Memory
AS SELECT
stochasticLinearRegressionState(0.1, 0.0, 5, 'SGD')(target, x1, x2)
AS state FROM train_data
```

```response title=Response theme={null}
Salva o estado do modelo treinado na tabela
```

**Fazendo previsões**

```sql title=Query theme={null}
WITH (SELECT state FROM your_model) AS model SELECT
evalMLMethod(model, x1, x2) FROM test_data
```

```response title=Response theme={null}
Retorna valores previstos para os dados de teste
```

**Obtendo os pesos do modelo**

```sql title=Query theme={null}
SELECT stochasticLinearRegression(0.01)(target, x1, x2) FROM train_data
```

```response title=Response theme={null}
Retorna os pesos do modelo sem salvar o estado
```

**Veja também**

* [stochasticLogisticRegression](/pt-BR/reference/functions/aggregate-functions/stochasticLogisticRegression)
* [Diferença entre regressão linear e regressão logística](https://stackoverflow.com/questions/12146914/what-is-the-difference-between-linear-regression-and-logistic-regression)