mirror of
https://github.com/ClickHouse/ClickHouse.git
synced 2024-09-24 18:50:49 +00:00
1197 lines
59 KiB
Markdown
1197 lines
59 KiB
Markdown
# Справочник функций
|
||
|
||
## count {#agg_function-count}
|
||
|
||
Вычисляет количество строк или не NULL значений .
|
||
|
||
ClickHouse поддерживает следующие виды синтаксиса для `count`:
|
||
|
||
- `count(expr)` или `COUNT(DISTINCT expr)`.
|
||
- `count()` или `COUNT(*)`. Синтаксис `count()` специфичен для ClickHouse.
|
||
|
||
**Параметры**
|
||
|
||
Функция может принимать:
|
||
|
||
- Ноль параметров.
|
||
- Одно [выражение](../syntax.md#syntax-expressions).
|
||
|
||
**Возвращаемое значение**
|
||
|
||
- Если функция вызывается без параметров, она вычисляет количество строк.
|
||
- Если передаётся [выражение](../syntax.md#syntax-expressions) , то функция вычисляет количество раз, когда выражение возвращает не NULL. Если выражение возвращает значение типа [Nullable](../../data_types/nullable.md), то результат `count` не становится `Nullable`. Функция возвращает 0, если выражение возвращает `NULL` для всех строк.
|
||
|
||
В обоих случаях тип возвращаемого значения [UInt64](../../data_types/int_uint.md).
|
||
|
||
**Подробности**
|
||
|
||
ClickHouse поддерживает синтаксис `COUNT(DISTINCT ...)`. Поведение этой конструкции зависит от настройки [count_distinct_implementation](../../operations/settings/settings.md#settings-count_distinct_implementation). Она определяет, какая из функций [uniq*](#agg_function-uniq) используется для выполнения операции. По умолчанию — функция [uniqExact](#agg_function-uniqexact).
|
||
|
||
Запрос `SELECT count() FROM table` не оптимизирован, поскольку количество записей в таблице не хранится отдельно. Он выбирает небольшой столбец из таблицы и подсчитывает количество значений в нём.
|
||
|
||
**Примеры**
|
||
|
||
Пример 1:
|
||
|
||
```sql
|
||
SELECT count() FROM t
|
||
```
|
||
|
||
```text
|
||
┌─count()─┐
|
||
│ 5 │
|
||
└─────────┘
|
||
```
|
||
|
||
Пример 2:
|
||
|
||
```sql
|
||
SELECT name, value FROM system.settings WHERE name = 'count_distinct_implementation'
|
||
```
|
||
|
||
```text
|
||
┌─name──────────────────────────┬─value─────┐
|
||
│ count_distinct_implementation │ uniqExact │
|
||
└───────────────────────────────┴───────────┘
|
||
```
|
||
|
||
```sql
|
||
SELECT count(DISTINCT num) FROM t
|
||
```
|
||
|
||
```text
|
||
┌─uniqExact(num)─┐
|
||
│ 3 │
|
||
└────────────────┘
|
||
```
|
||
|
||
Этот пример показывает, что `count(DISTINCT num)` выполняется с помощью функции `uniqExact` в соответствии со значением настройки `count_distinct_implementation`.
|
||
|
||
## any(x) {#agg_function-any}
|
||
|
||
Выбирает первое попавшееся значение.
|
||
Порядок выполнения запроса может быть произвольным и даже каждый раз разным, поэтому результат данной функции недетерминирован.
|
||
Для получения детерминированного результата, можно использовать функции min или max вместо any.
|
||
|
||
В некоторых случаях, вы всё-таки можете рассчитывать на порядок выполнения запроса. Это - случаи, когда SELECT идёт из подзапроса, в котором используется ORDER BY.
|
||
|
||
При наличии в запросе `SELECT` секции `GROUP BY` или хотя бы одной агрегатной функции, ClickHouse (в отличие от, например, MySQL) требует, чтобы все выражения в секциях `SELECT`, `HAVING`, `ORDER BY` вычислялись из ключей или из агрегатных функций. То есть, каждый выбираемый из таблицы столбец, должен использоваться либо в ключах, либо внутри агрегатных функций. Чтобы получить поведение, как в MySQL, вы можете поместить остальные столбцы в агрегатную функцию `any`.
|
||
|
||
## anyHeavy(x) {#agg_function-anyHeavy}
|
||
|
||
Выбирает часто встречающееся значение с помощью алгоритма "[heavy hitters](http://www.cs.umd.edu/~samir/498/karp.pdf)". Если существует значение, которое встречается чаще, чем в половине случаев, в каждом потоке выполнения запроса, то возвращается данное значение. В общем случае, результат недетерминирован.
|
||
|
||
```sql
|
||
anyHeavy(column)
|
||
```
|
||
|
||
**Аргументы**
|
||
|
||
- `column` — имя столбца.
|
||
|
||
**Пример**
|
||
|
||
Возьмём набор данных [OnTime](../../getting_started/example_datasets/ontime.md) и выберем произвольное часто встречающееся значение в столбце `AirlineID`.
|
||
|
||
```sql
|
||
SELECT anyHeavy(AirlineID) AS res
|
||
FROM ontime
|
||
```
|
||
|
||
```text
|
||
┌───res─┐
|
||
│ 19690 │
|
||
└───────┘
|
||
```
|
||
|
||
## anyLast(x) {#agg_function-anyLast}
|
||
|
||
Выбирает последнее попавшееся значение.
|
||
Результат так же недетерминирован, как и для функции `any`.
|
||
|
||
##groupBitAnd
|
||
|
||
Применяет побитовое `И` для последовательности чисел.
|
||
|
||
```sql
|
||
groupBitAnd(expr)
|
||
```
|
||
|
||
**Параметры**
|
||
|
||
`expr` – выражение, результат которого имеет тип данных `UInt*`.
|
||
|
||
**Возвращаемое значение**
|
||
|
||
Значение типа `UInt*`.
|
||
|
||
**Пример**
|
||
|
||
Тестовые данные:
|
||
|
||
```text
|
||
binary decimal
|
||
00101100 = 44
|
||
00011100 = 28
|
||
00001101 = 13
|
||
01010101 = 85
|
||
```
|
||
|
||
Запрос:
|
||
|
||
```sql
|
||
SELECT groupBitAnd(num) FROM t
|
||
```
|
||
|
||
Где `num` — столбец с тестовыми данными.
|
||
|
||
Результат:
|
||
|
||
```text
|
||
binary decimal
|
||
00000100 = 4
|
||
```
|
||
|
||
##groupBitOr
|
||
|
||
Применяет побитовое `ИЛИ` для последовательности чисел.
|
||
|
||
```sql
|
||
groupBitOr(expr)
|
||
```
|
||
|
||
**Параметры**
|
||
|
||
`expr` – выражение, результат которого имеет тип данных `UInt*`.
|
||
|
||
**Возвращаемое значение**
|
||
|
||
Значение типа `UInt*`.
|
||
|
||
**Пример**
|
||
|
||
Тестовые данные:
|
||
|
||
```text
|
||
binary decimal
|
||
00101100 = 44
|
||
00011100 = 28
|
||
00001101 = 13
|
||
01010101 = 85
|
||
```
|
||
|
||
Запрос:
|
||
|
||
```sql
|
||
SELECT groupBitOr(num) FROM t
|
||
```
|
||
|
||
Где `num` — столбец с тестовыми данными.
|
||
|
||
Результат:
|
||
|
||
```text
|
||
binary decimal
|
||
01111101 = 125
|
||
```
|
||
|
||
##groupBitXor
|
||
|
||
Применяет побитовое `ИСКЛЮЧАЮЩЕЕ ИЛИ` для последовательности чисел.
|
||
|
||
```sql
|
||
groupBitXor(expr)
|
||
```
|
||
|
||
**Параметры**
|
||
|
||
`expr` – выражение, результат которого имеет тип данных `UInt*`.
|
||
|
||
**Возвращаемое значение**
|
||
|
||
Значение типа `UInt*`.
|
||
|
||
**Пример**
|
||
|
||
Тестовые данные:
|
||
|
||
```text
|
||
binary decimal
|
||
00101100 = 44
|
||
00011100 = 28
|
||
00001101 = 13
|
||
01010101 = 85
|
||
```
|
||
|
||
Запрос:
|
||
|
||
```sql
|
||
SELECT groupBitXor(num) FROM t
|
||
```
|
||
|
||
Где `num` — столбец с тестовыми данными.
|
||
|
||
Результат:
|
||
|
||
```text
|
||
binary decimal
|
||
01101000 = 104
|
||
```
|
||
|
||
## groupBitmap
|
||
|
||
Bitmap или агрегатные вычисления для столбца с типом данных `UInt*`, возвращают кардинальность в виде значения типа UInt64, если добавить суффикс -State, то возвращают [объект bitmap](../functions/bitmap_functions.md).
|
||
|
||
```sql
|
||
groupBitmap(expr)
|
||
```
|
||
|
||
**Параметры**
|
||
|
||
`expr` – выражение, результат которого имеет тип данных `UInt*`.
|
||
|
||
**Возвращаемое значение**
|
||
|
||
Значение типа `UInt64`.
|
||
|
||
**Пример**
|
||
|
||
Тестовые данные:
|
||
|
||
```text
|
||
UserID
|
||
1
|
||
1
|
||
2
|
||
3
|
||
```
|
||
|
||
Запрос:
|
||
|
||
```sql
|
||
SELECT groupBitmap(UserID) as num FROM t
|
||
```
|
||
|
||
Результат:
|
||
|
||
```text
|
||
num
|
||
3
|
||
```
|
||
|
||
## min(x) {#agg_function-min}
|
||
|
||
Вычисляет минимум.
|
||
|
||
## max(x) {#agg_function-max}
|
||
|
||
Вычисляет максимум.
|
||
|
||
## argMin(arg, val) {#agg_function-argMin}
|
||
|
||
Вычисляет значение arg при минимальном значении val. Если есть несколько разных значений arg для минимальных значений val, то выдаётся первое попавшееся из таких значений.
|
||
|
||
**Пример:**
|
||
|
||
```text
|
||
┌─user─────┬─salary─┐
|
||
│ director │ 5000 │
|
||
│ manager │ 3000 │
|
||
│ worker │ 1000 │
|
||
└──────────┴────────┘
|
||
```
|
||
```sql
|
||
SELECT argMin(user, salary) FROM salary
|
||
```
|
||
```text
|
||
┌─argMin(user, salary)─┐
|
||
│ worker │
|
||
└──────────────────────┘
|
||
```
|
||
|
||
## argMax(arg, val) {#agg_function-argMax}
|
||
|
||
Вычисляет значение arg при максимальном значении val. Если есть несколько разных значений arg для максимальных значений val, то выдаётся первое попавшееся из таких значений.
|
||
|
||
|
||
## sum(x) {#agg_function-sum}
|
||
|
||
Вычисляет сумму.
|
||
Работает только для чисел.
|
||
|
||
## sumWithOverflow(x) {#agg_function-sumWithOverflow}
|
||
|
||
Вычисляет сумму чисел, используя для результата тот же тип данных, что и для входных параметров. Если сумма выйдет за максимальное значение для заданного типа данных, то функция вернёт ошибку.
|
||
|
||
Работает только для чисел.
|
||
|
||
|
||
## sumMap(key, value)
|
||
|
||
Производит суммирование массива 'value' по соответствующим ключам заданным в массиве 'key'.
|
||
Количество элементов в 'key' и 'value' должно быть одинаковым для каждой строки, для которой происходит суммирование.
|
||
Возвращает кортеж из двух массивов - ключи в отсортированном порядке и значения, просуммированные по соответствующим ключам.
|
||
|
||
Пример:
|
||
|
||
```sql
|
||
CREATE TABLE sum_map(
|
||
date Date,
|
||
timeslot DateTime,
|
||
statusMap Nested(
|
||
status UInt16,
|
||
requests UInt64
|
||
)
|
||
) ENGINE = Log;
|
||
INSERT INTO sum_map VALUES
|
||
('2000-01-01', '2000-01-01 00:00:00', [1, 2, 3], [10, 10, 10]),
|
||
('2000-01-01', '2000-01-01 00:00:00', [3, 4, 5], [10, 10, 10]),
|
||
('2000-01-01', '2000-01-01 00:01:00', [4, 5, 6], [10, 10, 10]),
|
||
('2000-01-01', '2000-01-01 00:01:00', [6, 7, 8], [10, 10, 10]);
|
||
SELECT
|
||
timeslot,
|
||
sumMap(statusMap.status, statusMap.requests)
|
||
FROM sum_map
|
||
GROUP BY timeslot
|
||
```
|
||
|
||
```text
|
||
┌────────────timeslot─┬─sumMap(statusMap.status, statusMap.requests)─┐
|
||
│ 2000-01-01 00:00:00 │ ([1,2,3,4,5],[10,10,20,10,10]) │
|
||
│ 2000-01-01 00:01:00 │ ([4,5,6,7,8],[10,10,20,10,10]) │
|
||
└─────────────────────┴──────────────────────────────────────────────┘
|
||
```
|
||
|
||
## skewPop
|
||
|
||
Вычисляет [коэффициент асимметрии](https://ru.wikipedia.org/wiki/Коэффициент_асимметрии) для последовательности.
|
||
|
||
```sql
|
||
skewPop(expr)
|
||
```
|
||
|
||
**Параметры**
|
||
|
||
`expr` — [Выражение](../syntax.md#syntax-expressions), возвращающее число.
|
||
|
||
**Возвращаемое значение**
|
||
|
||
Коэффициент асимметрии заданного распределения. Тип — [Float64](../../data_types/float.md)
|
||
|
||
**Пример**
|
||
|
||
```sql
|
||
SELECT skewPop(value) FROM series_with_value_column
|
||
```
|
||
|
||
## skewSamp
|
||
|
||
Вычисляет [выборочный коэффициент асимметрии](https://ru.wikipedia.org/wiki/Статистика_(функция_выборки)) для последовательности.
|
||
|
||
Он представляет собой несмещенную оценку асимметрии случайной величины, если переданные значения образуют ее выборку.
|
||
|
||
```sql
|
||
skewSamp(expr)
|
||
```
|
||
|
||
**Параметры**
|
||
|
||
`expr` — [Выражение](../syntax.md#syntax-expressions), возвращающее число.
|
||
|
||
**Возвращаемое значение**
|
||
|
||
Коэффициент асимметрии заданного распределения. Тип — [Float64](../../data_types/float.md). Если `n <= 1` (`n` — размер выборки), тогда функция возвращает `nan`.
|
||
|
||
**Пример**
|
||
|
||
```sql
|
||
SELECT skewSamp(value) FROM series_with_value_column
|
||
```
|
||
|
||
## kurtPop
|
||
|
||
Вычисляет [коэффициент эксцесса](https://ru.wikipedia.org/wiki/Коэффициент_эксцесса) последовательности.
|
||
|
||
```sql
|
||
kurtPop(expr)
|
||
```
|
||
|
||
**Параметры**
|
||
|
||
`expr` — [Выражение](../syntax.md#syntax-expressions), возвращающее число.
|
||
|
||
**Возвращаемое значение**
|
||
|
||
Коэффициент эксцесса заданного распределения. Тип — [Float64](../../data_types/float.md)
|
||
|
||
**Пример**
|
||
|
||
```sql
|
||
SELECT kurtPop(value) FROM series_with_value_column
|
||
```
|
||
|
||
## kurtSamp
|
||
|
||
Вычисляет [выборочный коэффициент эксцесса](https://ru.wikipedia.org/wiki/Статистика_(функция_выборки)) для последовательности.
|
||
|
||
Он представляет собой несмещенную оценку эксцесса случайной величины, если переданные значения образуют ее выборку.
|
||
|
||
```sql
|
||
kurtSamp(expr)
|
||
```
|
||
|
||
**Параметры**
|
||
|
||
`expr` — [Выражение](../syntax.md#syntax-expressions), возвращающее число.
|
||
|
||
**Возвращаемое значение**
|
||
|
||
Коэффициент эксцесса заданного распределения. Тип — [Float64](../../data_types/float.md). Если `n <= 1` (`n` — размер выборки), тогда функция возвращает `nan`.
|
||
|
||
**Пример**
|
||
|
||
```sql
|
||
SELECT kurtSamp(value) FROM series_with_value_column
|
||
```
|
||
|
||
## timeSeriesGroupSum(uid, timestamp, value) {#agg_function-timeseriesgroupsum}
|
||
|
||
`timeSeriesGroupSum` агрегирует временные ряды в которых не совпадают моменты.
|
||
Функция использует линейную интерполяцию между двумя значениями времени, а затем суммирует значения для одного и того же момента (как измеренные так и интерполированные) по всем рядам.
|
||
|
||
- `uid` уникальный идентификатор временного ряда, `UInt64`.
|
||
- `timestamp` имеет тип `Int64` чтобы можно было учитывать милли и микросекунды.
|
||
- `value` представляет собой значение метрики.
|
||
|
||
Функция возвращает массив кортежей с парами `(timestamp, aggregated_value)`.
|
||
|
||
Временные ряды должны быть отсортированы по возрастанию `timestamp`.
|
||
|
||
Пример:
|
||
|
||
```text
|
||
┌─uid─┬─timestamp─┬─value─┐
|
||
│ 1 │ 2 │ 0.2 │
|
||
│ 1 │ 7 │ 0.7 │
|
||
│ 1 │ 12 │ 1.2 │
|
||
│ 1 │ 17 │ 1.7 │
|
||
│ 1 │ 25 │ 2.5 │
|
||
│ 2 │ 3 │ 0.6 │
|
||
│ 2 │ 8 │ 1.6 │
|
||
│ 2 │ 12 │ 2.4 │
|
||
│ 2 │ 18 │ 3.6 │
|
||
│ 2 │ 24 │ 4.8 │
|
||
└─────┴───────────┴───────┘
|
||
```
|
||
|
||
```sql
|
||
CREATE TABLE time_series(
|
||
uid UInt64,
|
||
timestamp Int64,
|
||
value Float64
|
||
) ENGINE = Memory;
|
||
INSERT INTO time_series VALUES
|
||
(1,2,0.2),(1,7,0.7),(1,12,1.2),(1,17,1.7),(1,25,2.5),
|
||
(2,3,0.6),(2,8,1.6),(2,12,2.4),(2,18,3.6),(2,24,4.8);
|
||
|
||
SELECT timeSeriesGroupSum(uid, timestamp, value)
|
||
FROM (
|
||
SELECT * FROM time_series order by timestamp ASC
|
||
);
|
||
```
|
||
|
||
И результат будет:
|
||
|
||
```text
|
||
[(2,0.2),(3,0.9),(7,2.1),(8,2.4),(12,3.6),(17,5.1),(18,5.4),(24,7.2),(25,2.5)]
|
||
```
|
||
|
||
## timeSeriesGroupRateSum(uid, ts, val) {#agg_function-timeseriesgroupratesum}
|
||
|
||
Аналогично timeSeriesGroupRateSum, timeSeriesGroupRateSum будет вычислять производные по timestamp для рядов, а затем суммировать полученные производные для всех рядов для одного значения timestamp.
|
||
Также ряды должны быть отсортированы по возрастанию timestamp.
|
||
|
||
Для пример из описания timeSeriesGroupRateSum результат будет следующим:
|
||
|
||
```text
|
||
[(2,0),(3,0.1),(7,0.3),(8,0.3),(12,0.3),(17,0.3),(18,0.3),(24,0.3),(25,0.1)]
|
||
```
|
||
|
||
## avg(x) {#agg_function-avg}
|
||
|
||
Вычисляет среднее.
|
||
Работает только для чисел.
|
||
Результат всегда Float64.
|
||
|
||
## uniq {#agg_function-uniq}
|
||
|
||
Приближённо вычисляет количество различных значений аргумента.
|
||
|
||
```sql
|
||
uniq(x[, ...])
|
||
```
|
||
|
||
**Параметры**
|
||
|
||
Функция принимает переменное число входных параметров. Параметры могут быть числовых типов, а также `Tuple`, `Array`, `Date`, `DateTime`, `String`.
|
||
|
||
**Возвращаемое значение**
|
||
|
||
- Значение с типом данных [UInt64](../../data_types/int_uint.md).
|
||
|
||
**Детали реализации**
|
||
|
||
Функция:
|
||
|
||
- Вычисляет хэш для всех параметров агрегации, а затем использует его в вычислениях.
|
||
|
||
- Использует адаптивный алгоритм выборки. В качестве состояния вычисления функция использует выборку хэш-значений элементов размером до 65536.
|
||
|
||
Этот алгоритм очень точен и очень эффективен по использованию CPU. Если запрос содержит небольшое количество этих функций, использование `uniq` почти так же эффективно, как и использование других агрегатных функций.
|
||
|
||
- Результат детерминирован (не зависит от порядка выполнения запроса).
|
||
|
||
Эту функцию рекомендуется использовать практически во всех сценариях.
|
||
|
||
**Смотрите также**
|
||
|
||
- [uniqCombined](#agg_function-uniqcombined)
|
||
- [uniqCombined64](#agg_function-uniqcombined64)
|
||
- [uniqHLL12](#agg_function-uniqhll12)
|
||
- [uniqExact](#agg_function-uniqexact)
|
||
|
||
## uniqCombined {#agg_function-uniqcombined}
|
||
|
||
Приближённо вычисляет количество различных значений аргумента.
|
||
|
||
```sql
|
||
uniqCombined(HLL_precision)(x[, ...])
|
||
```
|
||
|
||
Функция `uniqCombined` — это хороший выбор для вычисления количества различных значений.
|
||
|
||
**Параметры**
|
||
|
||
Функция принимает переменное число входных параметров. Параметры могут быть числовых типов, а также `Tuple`, `Array`, `Date`, `DateTime`, `String`.
|
||
|
||
`HLL_precision` — это логарифм по основанию 2 от числа ячеек в [HyperLogLog](https://en.wikipedia.org/wiki/HyperLogLog). Необязательный, можно использовать функцию как `uniqCombined (x [,...])`. Для `HLL_precision` значение по умолчанию — 17, что фактически составляет 96 КБ пространства (2^17 ячеек, 6 бит каждая).
|
||
|
||
**Возвращаемое значение**
|
||
|
||
- Число типа [UInt64](../../data_types/int_uint.md).
|
||
|
||
**Детали реализации**
|
||
|
||
Функция:
|
||
|
||
- Вычисляет хэш (64-битный для `String` и 32-битный для всех остальных типов) для всех параметров агрегации, а затем использует его в вычислениях.
|
||
|
||
- Используется комбинация трёх алгоритмов: массив, хэш-таблица и HyperLogLog с таблицей коррекции погрешности.
|
||
|
||
Для небольшого количества различных значений используется массив. Если размер набора больше, используется хэш-таблица. При дальнейшем увеличении количества значений, используется структура HyperLogLog, имеющая фиксированный размер в памяти.
|
||
|
||
- Результат детерминирован (не зависит от порядка выполнения запроса).
|
||
|
||
!!! note "Note"
|
||
Так как используется 32-битный хэш для не-`String` типов, результат будет иметь очень очень большую ошибку для количества разичных элементов существенно больше `UINT_MAX` (ошибка быстро растёт начиная с нескольких десятков миллиардов различных значений), таким образом в этом случае нужно использовать [uniqCombined64](#agg_function-uniqcombined64)
|
||
|
||
По сравнению с функцией [uniq](#agg_function-uniq), `uniqCombined`:
|
||
|
||
- Потребляет в несколько раз меньше памяти.
|
||
- Вычисляет с в несколько раз более высокой точностью.
|
||
- Обычно имеет немного более низкую производительность. В некоторых сценариях `uniqCombined` может показывать более высокую производительность, чем `uniq`, например, в случае распределенных запросов, при которых по сети передаётся большое количество состояний агрегации.
|
||
|
||
**Смотрите также**
|
||
|
||
- [uniq](#agg_function-uniq)
|
||
- [uniqCombined64](#agg_function-uniqcombined64)
|
||
- [uniqHLL12](#agg_function-uniqhll12)
|
||
- [uniqExact](#agg_function-uniqexact)
|
||
|
||
## uniqCombined64 {#agg_function-uniqcombined64}
|
||
|
||
Использует 64-битный хэш для всех типов, в отличие от [uniqCombined](#agg_function-uniqcombined).
|
||
|
||
## uniqHLL12 {#agg_function-uniqhll12}
|
||
|
||
Вычисляет приблизительное число различных значений аргументов, используя алгоритм [HyperLogLog](https://en.wikipedia.org/wiki/HyperLogLog).
|
||
|
||
```sql
|
||
uniqHLL12(x[, ...])
|
||
```
|
||
|
||
**Параметры**
|
||
|
||
Функция принимает переменное число входных параметров. Параметры могут быть числовых типов, а также `Tuple`, `Array`, `Date`, `DateTime`, `String`.
|
||
|
||
**Возвращаемое значение**
|
||
|
||
- Значение хэша с типом данных [UInt64](../../data_types/int_uint.md).
|
||
|
||
**Детали реализации**
|
||
|
||
Функция:
|
||
|
||
- Вычисляет хэш для всех параметров агрегации, а затем использует его в вычислениях.
|
||
|
||
- Использует алгоритм HyperLogLog для аппроксимации числа различных значений аргументов.
|
||
|
||
Используется 212 5-битовых ячеек. Размер состояния чуть больше 2.5 КБ. Результат не точный (ошибка до ~10%) для небольших множеств (<10K элементов). Однако для множеств большой кардинальности (10K - 100M) результат довольно точен (ошибка до ~1.6%). Начиная с 100M ошибка оценки будет только расти и для множеств огромной кардинальности (1B+ элементов) функция возвращает результат с очень большой неточностью.
|
||
|
||
- Результат детерминирован (не зависит от порядка выполнения запроса).
|
||
|
||
Мы не рекомендуем использовать эту функцию. В большинстве случаев используйте функцию [uniq](#agg_function-uniq) или [uniqCombined](#agg_function-uniqcombined).
|
||
|
||
**Смотрите также**
|
||
|
||
- [uniq](#agg_function-uniq)
|
||
- [uniqCombined](#agg_function-uniqcombined)
|
||
- [uniqExact](#agg_function-uniqexact)
|
||
|
||
## uniqExact {#agg_function-uniqexact}
|
||
|
||
Вычисляет точное количество различных значений аргументов.
|
||
|
||
```sql
|
||
uniqExact(x[, ...])
|
||
```
|
||
|
||
Функцию `uniqExact` следует использовать, если вам обязательно нужен точный результат. В противном случае используйте функцию [uniq](#agg_function-uniq).
|
||
|
||
Функция `uniqExact` расходует больше оперативной памяти, чем функция `uniq`, так как размер состояния неограниченно растёт по мере роста количества различных значений.
|
||
|
||
**Параметры**
|
||
|
||
Функция принимает переменное число входных параметров. Параметры могут быть числовых типов, а также `Tuple`, `Array`, `Date`, `DateTime`, `String`.
|
||
|
||
**Смотрите также**
|
||
|
||
- [uniq](#agg_function-uniq)
|
||
- [uniqCombined](#agg_function-uniqcombined)
|
||
- [uniqHLL12](#agg_function-uniqhll12)
|
||
|
||
## groupArray(x), groupArray(max_size)(x) {#agg_function-grouparray}
|
||
|
||
Составляет массив из значений аргумента.
|
||
Значения в массив могут быть добавлены в любом (недетерминированном) порядке.
|
||
|
||
Вторая версия (с параметром `max_size`) ограничивает размер результирующего массива `max_size` элементами.
|
||
Например, `groupArray(1)(x)` эквивалентно `[any(x)]`.
|
||
|
||
В некоторых случаях, вы всё же можете рассчитывать на порядок выполнения запроса. Это — случаи, когда `SELECT` идёт из подзапроса, в котором используется `ORDER BY`.
|
||
|
||
|
||
## groupArrayInsertAt(x)
|
||
|
||
Вставляет в массив значение в заданную позицию.
|
||
|
||
Принимает на вход значение и позицию. Если на одну и ту же позицию вставляется несколько значений, в результирующем массиве может оказаться любое (первое в случае однопоточного выполнения). Если в позицию не вставляется ни одного значения, то позиции присваивается значение по умолчанию.
|
||
|
||
Опциональные параметры:
|
||
|
||
- Значение по умолчанию для подстановки на пустые позиции.
|
||
- Длина результирующего массива. Например, если вы хотите получать массивы одинакового размера для всех агрегатных ключей. При использовании этого параметра значение по умолчанию задавать обязательно.
|
||
|
||
## groupArrayMovingSum {#agg_function-grouparraymovingsum}
|
||
|
||
Вычисляет скользящую сумму входных значений.
|
||
|
||
```sql
|
||
groupArrayMovingSum(numbers_for_summing)
|
||
groupArrayMovingSum(window_size)(numbers_for_summing)
|
||
```
|
||
|
||
Функция может принимать размер окна в качестве параметра. Если окно не указано, то функция использует размер окна, равный количеству строк в столбце.
|
||
|
||
**Параметры**
|
||
|
||
- `numbers_for_summing` — [выражение](../syntax.md#syntax-expressions), возвращающее значение числового типа.
|
||
- `window_size` — размер окна.
|
||
|
||
**Возвращаемые значения**
|
||
|
||
- Массив того же размера и типа, что и входные данные.
|
||
|
||
**Пример**
|
||
|
||
Таблица с исходными данными:
|
||
|
||
```sql
|
||
CREATE TABLE t
|
||
(
|
||
`int` UInt8,
|
||
`float` Float32,
|
||
`dec` Decimal32(2)
|
||
)
|
||
ENGINE = TinyLog
|
||
```
|
||
|
||
```text
|
||
┌─int─┬─float─┬──dec─┐
|
||
│ 1 │ 1.1 │ 1.10 │
|
||
│ 2 │ 2.2 │ 2.20 │
|
||
│ 4 │ 4.4 │ 4.40 │
|
||
│ 7 │ 7.77 │ 7.77 │
|
||
└─────┴───────┴──────┘
|
||
```
|
||
|
||
Запросы:
|
||
|
||
```sql
|
||
SELECT
|
||
groupArrayMovingSum(int) AS I,
|
||
groupArrayMovingSum(float) AS F,
|
||
groupArrayMovingSum(dec) AS D
|
||
FROM t
|
||
```
|
||
|
||
```text
|
||
┌─I──────────┬─F───────────────────────────────┬─D──────────────────────┐
|
||
│ [1,3,7,14] │ [1.1,3.3000002,7.7000003,15.47] │ [1.10,3.30,7.70,15.47] │
|
||
└────────────┴─────────────────────────────────┴────────────────────────┘
|
||
```
|
||
|
||
```sql
|
||
SELECT
|
||
groupArrayMovingSum(2)(int) AS I,
|
||
groupArrayMovingSum(2)(float) AS F,
|
||
groupArrayMovingSum(2)(dec) AS D
|
||
FROM t
|
||
```
|
||
|
||
```text
|
||
┌─I──────────┬─F───────────────────────────────┬─D──────────────────────┐
|
||
│ [1,3,6,11] │ [1.1,3.3000002,6.6000004,12.17] │ [1.10,3.30,6.60,12.17] │
|
||
└────────────┴─────────────────────────────────┴────────────────────────┘
|
||
```
|
||
|
||
## groupArrayMovingAvg {#agg_function-grouparraymovingavg}
|
||
|
||
Вычисляет скользящее среднее для входных значений.
|
||
|
||
```
|
||
groupArrayMovingAvg(numbers_for_summing)
|
||
groupArrayMovingAvg(window_size)(numbers_for_summing)
|
||
```
|
||
|
||
Функция может принимать размер окна в качестве параметра. Если окно не указано, то функция использует размер окна, равный количеству строк в столбце.
|
||
|
||
**Параметры**
|
||
|
||
- `numbers_for_summing` — [выражение](../syntax.md#syntax-expressions), возвращающее значение числового типа.
|
||
- `window_size` — размер окна.
|
||
|
||
**Возвращаемые значения**
|
||
|
||
- Массив того же размера и типа, что и входные данные.
|
||
|
||
Функция использует [округление к меньшему по модулю](https://ru.wikipedia.org/wiki/Округление#Методы). Оно усекает десятичные разряды, незначимые для результирующего типа данных.
|
||
|
||
**Пример**
|
||
|
||
Таблица с исходными данными:
|
||
|
||
```sql
|
||
CREATE TABLE t
|
||
(
|
||
`int` UInt8,
|
||
`float` Float32,
|
||
`dec` Decimal32(2)
|
||
)
|
||
ENGINE = TinyLog
|
||
```
|
||
|
||
```text
|
||
┌─int─┬─float─┬──dec─┐
|
||
│ 1 │ 1.1 │ 1.10 │
|
||
│ 2 │ 2.2 │ 2.20 │
|
||
│ 4 │ 4.4 │ 4.40 │
|
||
│ 7 │ 7.77 │ 7.77 │
|
||
└─────┴───────┴──────┘
|
||
```
|
||
|
||
Запросы:
|
||
|
||
```sql
|
||
SELECT
|
||
groupArrayMovingAvg(int) AS I,
|
||
groupArrayMovingAvg(float) AS F,
|
||
groupArrayMovingAvg(dec) AS D
|
||
FROM t
|
||
```
|
||
|
||
```text
|
||
┌─I─────────┬─F───────────────────────────────────┬─D─────────────────────┐
|
||
│ [0,0,1,3] │ [0.275,0.82500005,1.9250001,3.8675] │ [0.27,0.82,1.92,3.86] │
|
||
└───────────┴─────────────────────────────────────┴───────────────────────┘
|
||
```
|
||
|
||
```sql
|
||
SELECT
|
||
groupArrayMovingAvg(2)(int) AS I,
|
||
groupArrayMovingAvg(2)(float) AS F,
|
||
groupArrayMovingAvg(2)(dec) AS D
|
||
FROM t
|
||
```
|
||
|
||
```text
|
||
┌─I─────────┬─F────────────────────────────────┬─D─────────────────────┐
|
||
│ [0,1,3,5] │ [0.55,1.6500001,3.3000002,6.085] │ [0.55,1.65,3.30,6.08] │
|
||
└───────────┴──────────────────────────────────┴───────────────────────┘
|
||
```
|
||
|
||
## groupUniqArray(x), groupUniqArray(max_size)(x)
|
||
|
||
Составляет массив из различных значений аргумента. Расход оперативной памяти такой же, как у функции `uniqExact`.
|
||
|
||
Функция `groupUniqArray(max_size)(x)` ограничивает размер результирующего массива до `max_size` элементов. Например, `groupUniqArray(1)(x)` равнозначно `[any(x)]`.
|
||
|
||
## quantile(level)(x) {#agg_function-quantile}
|
||
|
||
Приближённо вычисляет квантиль уровня level. level - константа, число с плавающей запятой от 0 до 1.
|
||
Рекомендуется использовать значения level в диапазоне `[0.01, 0.99]`.
|
||
Не используйте значение 'level' равное 0 или 1 – используйте функции 'min' и 'max' для этих случаев.
|
||
|
||
В этой функции, равно как и во всех функциях для расчёта квантилей, параметр level может быть не указан. В таком случае, он принимается равным 0.5 - то есть, функция будет вычислять медиану.
|
||
|
||
Работает для чисел, дат, дат-с-временем.
|
||
Для чисел возвращает Float64, для дат - дату, для дат-с-временем - дату-с-временем.
|
||
|
||
Используется [reservoir sampling](https://en.wikipedia.org/wiki/Reservoir_sampling) с размером резервуара до 8192.
|
||
При необходимости, результат выдаётся с линейной аппроксимацией из двух соседних значений.
|
||
Этот алгоритм обеспечивает весьма низкую точность расчёта. Смотрите также функции `quantileTiming`, `quantileTDigest`, `quantileExact`.
|
||
|
||
Результат зависит от порядка выполнения запроса, и является недетерминированным.
|
||
|
||
При использовании нескольких функций `quantile` (и аналогичных) с разными уровнями в запросе, внутренние состояния не объединяются (то есть, запрос работает менее эффективно, чем мог бы). В этом случае, используйте функцию `quantiles` (и аналогичные).
|
||
|
||
## quantileDeterministic(level)(x, determinator)
|
||
|
||
Работает аналогично функции `quantile`, но, в отличие от неё, результат является детерминированным и не зависит от порядка выполнения запроса.
|
||
|
||
Для этого, функция принимает второй аргумент - «детерминатор». Это некоторое число, хэш от которого используется вместо генератора случайных чисел в алгоритме reservoir sampling. Для правильной работы функции, одно и то же значение детерминатора не должно встречаться слишком часто. В качестве детерминатора вы можете использовать идентификатор события, идентификатор посетителя и т. п.
|
||
|
||
Не используйте эту функцию для расчёта таймингов. Для этого есть более подходящая функция - `quantileTiming`.
|
||
|
||
## quantileTiming {#agg_function-quantiletiming}
|
||
|
||
Вычисляет квантиль заданного уровня с детерминированной точностью. Функция предназначена для расчётов квантилей времени загрузки страниц в миллисекундах.
|
||
|
||
```
|
||
quantileTiming(level)(expr)
|
||
```
|
||
|
||
**Параметры**
|
||
|
||
- `level` — уровень квантили. Диапазон: [0, 1].
|
||
- `expr` — [выражение](../syntax.md#syntax-expressions), возвращающее число типа [Float*](../../data_types/float.md). Функция ожидает на вход значения в фомате UNIX-время в миллисекундах, но не проверяет формат входных значений.
|
||
|
||
- Поведение функции не определено для отрицательных входных значений.
|
||
- Если входное значение больше 30,000 (т.е. время загрузки страницы превышает 30 секунд), оно приравнивается к 30,000.
|
||
|
||
**Точность**
|
||
|
||
Вычисления точны если:
|
||
|
||
- Общее количество значений не превышает 5670.
|
||
- Общее количество значений больше 5670, но времена загрузки страниц меньше 1024мс.
|
||
|
||
В противном случае, результат рассчетов округляется до ближайшего числа, кратного 16мс.
|
||
|
||
!!! note "Примечание"
|
||
Для расчёта квантилей времени загрузки страниц, функция работает эффективней и с более высокой точностью, чем функция [quantile](#agg_function-quantile).
|
||
|
||
**Возвращаемое значение**
|
||
|
||
- Квантиль заданного уровня.
|
||
|
||
Тип: `Float32`.
|
||
|
||
!!! note "Примечание"
|
||
Если в функцию не передано значений (для `quantileTimingIf`), возвращается [NaN](../../data_types/float.md#data_type-float-nan-inf). Это необходимо для того, что бы отделить такие случаи от случаев, в которых результат 0. Смотрите замечания о сортировке значений `NaN` в разделе [Секция ORDER BY](../select.md#select-order-by).
|
||
|
||
Результат детерминирован (не зависит от порядка выполнения запроса).
|
||
|
||
**Пример**
|
||
|
||
```sql
|
||
SELECT quantileTiming(0.5)(number / 2) FROM numbers(10)
|
||
```
|
||
```text
|
||
┌─quantileTiming(0.5)(divide(number, 2))─┐
|
||
│ 2 │
|
||
└────────────────────────────────────────┘
|
||
```
|
||
|
||
## quantileTimingWeighted(level)(x, weight)
|
||
|
||
Отличается от функции `quantileTiming` наличием второго аргумента - «веса». Вес - неотрицательное целое число.
|
||
Результат считается так же, как если бы в функцию `quantileTiming` значение `x` было передано `weight` количество раз.
|
||
|
||
## quantileExact(level)(x)
|
||
|
||
Вычисляет квантиль уровня level точно. Для этого, все переданные значения складываются в массив, который затем частично сортируется. Поэтому, функция потребляет O(n) памяти, где n - количество переданных значений. Впрочем, для случая маленького количества значений, функция весьма эффективна.
|
||
|
||
## quantileExactWeighted(level)(x, weight)
|
||
|
||
Вычисляет квантиль уровня level точно. При этом, каждое значение учитывается с весом weight - как будто оно присутствует weight раз. Аргументы функции можно рассматривать как гистограммы, где значению x соответствует «столбик» гистограммы высоты weight, а саму функцию можно рассматривать как суммирование гистограмм.
|
||
|
||
В качестве алгоритма используется хэш-таблица. Из-за этого, в случае, если передаваемые значения часто повторяются, функция потребляет меньше оперативки, чем `quantileExact`. Вы можете использовать эту функцию вместо `quantileExact`, указав в качестве веса число 1.
|
||
|
||
## quantileTDigest(level)(x)
|
||
|
||
Вычисляет квантиль уровня level приближенно, с использованием алгоритма [t-digest](https://github.com/tdunning/t-digest/blob/master/docs/t-digest-paper/histo.pdf). Максимальная погрешность составляет 1%. Расход памяти на состояние пропорционален логарифму от количества переданных значений.
|
||
|
||
Производительность функции ниже `quantile`, `quantileTiming`. По соотношению размера состояния и точности, функция существенно лучше, чем `quantile`.
|
||
|
||
Результат зависит от порядка выполнения запроса, и является недетерминированным.
|
||
|
||
## median(x)
|
||
|
||
Для всех quantile-функций, также присутствуют соответствующие median-функции: `median`, `medianDeterministic`, `medianTiming`, `medianTimingWeighted`, `medianExact`, `medianExactWeighted`, `medianTDigest`. Они являются синонимами и их поведение ничем не отличается.
|
||
|
||
## quantiles(level1, level2, ...)(x)
|
||
|
||
Для всех quantile-функций, также присутствуют соответствующие quantiles-функции: `quantiles`, `quantilesDeterministic`, `quantilesTiming`, `quantilesTimingWeighted`, `quantilesExact`, `quantilesExactWeighted`, `quantilesTDigest`. Эти функции за один проход вычисляют все квантили перечисленных уровней и возвращают массив вычисленных значений.
|
||
|
||
## varSamp(x)
|
||
|
||
Вычисляет величину `Σ((x - x̅)^2) / (n - 1)`, где `n` - размер выборки, `x̅`- среднее значение `x`.
|
||
|
||
Она представляет собой несмещённую оценку дисперсии случайной величины, если переданные в функцию значения являются выборкой этой случайной величины.
|
||
|
||
Возвращает `Float64`. В случае, когда `n <= 1`, возвращается `+∞`.
|
||
|
||
## varPop(x)
|
||
|
||
Вычисляет величину `Σ((x - x̅)^2) / n`, где `n` - размер выборки, `x̅`- среднее значение `x`.
|
||
|
||
То есть, дисперсию для множества значений. Возвращает `Float64`.
|
||
|
||
## stddevSamp(x)
|
||
|
||
Результат равен квадратному корню от `varSamp(x)`.
|
||
|
||
## stddevPop(x)
|
||
|
||
Результат равен квадратному корню от `varPop(x)`.
|
||
|
||
## topK(N)(column)
|
||
|
||
Возвращает массив наиболее часто встречающихся значений в указанном столбце. Результирующий массив упорядочен по убыванию частоты значения (не по самим значениям).
|
||
|
||
Реализует [Filtered Space-Saving](http://www.l2f.inesc-id.pt/~fmmb/wiki/uploads/Work/misnis.ref0a.pdf) алгоритм для анализа TopK, на основе reduce-and-combine алгоритма из методики [Parallel Space Saving](https://arxiv.org/pdf/1401.0702.pdf).
|
||
|
||
```sql
|
||
topK(N)(column)
|
||
```
|
||
|
||
Функция не дает гарантированного результата. В некоторых ситуациях могут возникать ошибки, и функция возвращает частые, но не наиболее частые значения.
|
||
|
||
Рекомендуем использовать значения `N < 10`, при больших `N` снижается производительность. Максимально возможное значение `N = 65536`.
|
||
|
||
**Аргументы**
|
||
|
||
- 'N' - Количество значений.
|
||
- 'x' – Столбец.
|
||
|
||
**Пример**
|
||
|
||
Возьмём набор данных [OnTime](../../getting_started/example_datasets/ontime.md) и выберем 3 наиболее часто встречающихся значения в столбце `AirlineID`.
|
||
|
||
```sql
|
||
SELECT topK(3)(AirlineID) AS res
|
||
FROM ontime
|
||
```
|
||
|
||
```text
|
||
┌─res─────────────────┐
|
||
│ [19393,19790,19805] │
|
||
└─────────────────────┘
|
||
```
|
||
|
||
## covarSamp(x, y)
|
||
|
||
Вычисляет величину `Σ((x - x̅)(y - y̅)) / (n - 1)`.
|
||
|
||
Возвращает Float64. В случае, когда `n <= 1`, возвращается +∞.
|
||
|
||
## covarPop(x, y)
|
||
|
||
Вычисляет величину `Σ((x - x̅)(y - y̅)) / n`.
|
||
|
||
## corr(x, y)
|
||
|
||
Вычисляет коэффициент корреляции Пирсона: `Σ((x - x̅)(y - y̅)) / sqrt(Σ((x - x̅)^2) * Σ((y - y̅)^2))`.
|
||
|
||
## simpleLinearRegression
|
||
|
||
Выполняет простую (одномерную) линейную регрессию.
|
||
|
||
```sql
|
||
simpleLinearRegression(x, y)
|
||
```
|
||
|
||
Параметры:
|
||
|
||
- `x` — столбец со значениями зависимой переменной.
|
||
- `y` — столбец со значениями наблюдаемой переменной.
|
||
|
||
Возвращаемые значения:
|
||
|
||
Константы `(a, b)` результирующей прямой `y = a*x + b`.
|
||
|
||
**Примеры**
|
||
|
||
```sql
|
||
SELECT arrayReduce('simpleLinearRegression', [0, 1, 2, 3], [0, 1, 2, 3])
|
||
```
|
||
|
||
```text
|
||
┌─arrayReduce('simpleLinearRegression', [0, 1, 2, 3], [0, 1, 2, 3])─┐
|
||
│ (1,0) │
|
||
└───────────────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
```sql
|
||
SELECT arrayReduce('simpleLinearRegression', [0, 1, 2, 3], [3, 4, 5, 6])
|
||
```
|
||
|
||
```text
|
||
┌─arrayReduce('simpleLinearRegression', [0, 1, 2, 3], [3, 4, 5, 6])─┐
|
||
│ (1,3) │
|
||
└───────────────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
## stochasticLinearRegression {#agg_functions-stochasticlinearregression}
|
||
|
||
Функция реализует стохастическую линейную регрессию. Поддерживает пользовательские параметры для скорости обучения, коэффициента регуляризации L2, размера mini-batch и имеет несколько методов обновления весов ([Adam](https://en.wikipedia.org/wiki/Stochastic_gradient_descent#Adam) (по умолчанию), [simple SGD](https://en.wikipedia.org/wiki/Stochastic_gradient_descent), [Momentum](https://en.wikipedia.org/wiki/Stochastic_gradient_descent#Momentum), [Nesterov](https://mipt.ru/upload/medialibrary/d7e/41-91.pdf)).
|
||
|
||
### Параметры {#agg_functions-stochasticlinearregression-parameters}
|
||
|
||
Есть 4 настраиваемых параметра. Они передаются в функцию последовательно, однако не обязательно указывать все, используются значения по умолчанию, однако хорошая модель требует некоторой настройки параметров.
|
||
|
||
```text
|
||
stochasticLinearRegression(1.0, 1.0, 10, 'SGD')
|
||
```
|
||
|
||
1. Скорость обучения — коэффициент длины шага, при выполнении градиентного спуска. Слишком большая скорость обучения может привести к бесконечным весам модели. По умолчанию `0.00001`.
|
||
2. Коэффициент регуляризации l2. Помогает предотвратить подгонку. По умолчанию `0.1`.
|
||
3. Размер mini-batch задаёт количество элементов, чьи градиенты будут вычислены и просуммированы при выполнении одного шага градиентного спуска. Чистый стохастический спуск использует один элемент, однако использование mini-batch (около 10 элементов) делает градиентные шаги более стабильными. По умолчанию `15`.
|
||
4. Метод обновления весов, можно выбрать один из следующих: `Adam` (по умолчанию), `SGD`, `Momentum`, `Nesterov`. `Momentum` и `Nesterov` более требовательные к вычислительным ресурсам и памяти, однако они имеют высокую скорость схождения и устойчивости методов стохастического градиента.
|
||
|
||
|
||
### Использование {#agg_functions-stochasticlinearregression-usage}
|
||
|
||
`stochasticLinearRegression` используется на двух этапах: построение модели и предсказание новых данных. Чтобы построить модель и сохранить её состояние для дальнейшего использования, мы используем комбинатор `-State`.
|
||
Для прогнозирования мы используем функцию [evalMLMethod](../functions/machine_learning_functions.md#machine_learning_methods-evalmlmethod), которая принимает в качестве аргументов состояние и свойства для прогнозирования.
|
||
|
||
<a name="stochasticlinearregression-usage-fitting"></a>
|
||
|
||
**1.** Построение модели
|
||
|
||
Пример запроса:
|
||
|
||
```sql
|
||
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, param1, param2)
|
||
AS state FROM train_data;
|
||
```
|
||
|
||
Здесь нам также нужно вставить данные в таблицу `train_data`. Количество параметров не фиксировано, оно зависит только от количества аргументов, перешедших в `linearRegressionState`. Все они должны быть числовыми значениями.
|
||
Обратите внимание, что столбец с целевым значением (которое мы хотели бы научиться предсказывать) вставляется в качестве первого аргумента.
|
||
|
||
**2.** Прогнозирование
|
||
|
||
После сохранения состояния в таблице мы можем использовать его несколько раз для прогнозирования или смёржить с другими состояниями и создать новые, улучшенные модели.
|
||
|
||
```sql
|
||
WITH (SELECT state FROM your_model) AS model SELECT
|
||
evalMLMethod(model, param1, param2) FROM test_data
|
||
```
|
||
|
||
Запрос возвращает столбец прогнозируемых значений. Обратите внимание, что первый аргумент `evalMLMethod` это объект `AggregateFunctionState`, далее идут столбцы свойств.
|
||
|
||
`test_data` — это таблица, подобная `train_data`, но при этом может не содержать целевое значение.
|
||
|
||
### Примечания {#agg_functions-stochasticlinearregression-notes}
|
||
|
||
1. Объединить две модели можно следующим запросом:
|
||
|
||
```sql
|
||
SELECT state1 + state2 FROM your_models
|
||
```
|
||
|
||
где таблица `your_models` содержит обе модели. Запрос вернёт новый объект `AggregateFunctionState`.
|
||
|
||
2. Пользователь может получать веса созданной модели для своих целей без сохранения модели, если не использовать комбинатор `-State`.
|
||
|
||
```sql
|
||
SELECT stochasticLinearRegression(0.01)(target, param1, param2) FROM train_data
|
||
```
|
||
|
||
Подобный запрос строит модель и возвращает её веса, отвечающие параметрам моделей и смещение. Таким образом, в приведенном выше примере запрос вернет столбец с тремя значениями.
|
||
|
||
**Смотрите также**
|
||
|
||
- [stochasticLogisticRegression](#agg_functions-stochasticlogisticregression)
|
||
- [Отличие линейной от логистической регрессии.](https://stackoverflow.com/questions/12146914/what-is-the-difference-between-linear-regression-and-logistic-regression)
|
||
|
||
|
||
## stochasticLogisticRegression {#agg_functions-stochasticlogisticregression}
|
||
|
||
Функция реализует стохастическую логистическую регрессию. Её можно использовать для задачи бинарной классификации, функция поддерживает те же пользовательские параметры, что и stochasticLinearRegression и работает таким же образом.
|
||
|
||
### Параметры {#agg_functions-stochasticlogisticregression-parameters}
|
||
|
||
Параметры те же, что и в stochasticLinearRegression:
|
||
`learning rate`, `l2 regularization coefficient`, `mini-batch size`, `method for updating weights`.
|
||
Смотрите раздел [parameters](#agg_functions-stochasticlinearregression-parameters).
|
||
|
||
```text
|
||
stochasticLogisticRegression(1.0, 1.0, 10, 'SGD')
|
||
```
|
||
|
||
1. Построение модели
|
||
|
||
Смотрите раздел `Построение модели` в описании [stochasticLinearRegression](#stochasticlinearregression-usage-fitting) .
|
||
|
||
Прогнозируемые метки должны быть в диапазоне [-1, 1].
|
||
|
||
2. Прогнозирование
|
||
|
||
Используя сохраненное состояние, можно предсказать вероятность наличия у объекта метки `1`.
|
||
|
||
```sql
|
||
WITH (SELECT state FROM your_model) AS model SELECT
|
||
evalMLMethod(model, param1, param2) FROM test_data
|
||
```
|
||
|
||
Запрос возвращает столбец вероятностей. Обратите внимание, что первый аргумент `evalMLMethod` это объект `AggregateFunctionState`, далее идут столбцы свойств.
|
||
|
||
Мы также можем установить границу вероятности, которая присваивает элементам различные метки.
|
||
|
||
```sql
|
||
SELECT ans < 1.1 AND ans > 0.5 FROM
|
||
(WITH (SELECT state FROM your_model) AS model SELECT
|
||
evalMLMethod(model, param1, param2) AS ans FROM test_data)
|
||
```
|
||
|
||
Тогда результатом будут метки.
|
||
|
||
`test_data` — это таблица, подобная `train_data`, но при этом может не содержать целевое значение.
|
||
|
||
**Смотрите также**
|
||
|
||
- [stochasticLinearRegression](#agg_functions-stochasticlinearregression)
|
||
- [Отличие линейной от логистической регрессии](https://moredez.ru/q/51225972/)
|
||
|
||
[Оригинальная статья](https://clickhouse.yandex/docs/ru/query_language/agg_functions/reference/) <!--hide-->
|