Каков правильный алгоритм для кривой логарифмического распределения между двумя точками?

Благодаря помощи antti.huima я переосмыслил то, что пытался сделать.

Принимая его метод решения задачи, я хочу уравнение, в котором логарифм mincount равен линейному уравнению между двумя точками.

weight(MIN) = ln(MIN-(MIN-1)) + min_weight
min_weight = ln(1) + min_weight

Хотя это дает мне хорошую отправную точку, мне нужно, чтобы она прошла через точку (MAX, max_weight). Ему понадобится константа:

weight(x) = ln(x-(MIN-1))/K + min_weight

Решая K, получаем:

K = ln(MAX-(MIN-1))/(max_weight - min_weight)

Итак, чтобы поместить все это обратно в некоторый код Python:

from math import log
count = [1, 3, 5, 4, 7, 5, 10, 6]
def logdist(count, threshold=0, maxsize=1.75, minsize=.75):
    countdist = []
    # mincount is either the threshold or the minimum if it's over the threshold
    mincount = threshold<min(count) and min(count) or threshold
    maxcount = max(count)
    constant = log(maxcount - (mincount - 1)) / (maxsize - minsize)
    for c in count:
        size = log(c - (mincount - 1)) / constant + minsize
        countdist.append({'count': c, 'size': round(size, 3)})
    return countdist

Давайте начнем с сопоставления зарегистрированного количества с размером. Это линейное отображение, о котором вы упомянули:

   size
    |
max |_____
    |   /
    |  /|
    | / |
min |/  |
    |   |
   /|   |
0 /_|___|____
    0   a

где min и max — это минимальный и максимальный размеры, а a=log(maxcount)-b. Строка имеет вид y=mx+c, где x=log(count)-b

Из графика видно, что градиент m равен (maxsize-minsize)/a.

Нам нужно x=0 при y=minsize, поэтому log(mincount)-b=0 -> b=log(mincount)

Это оставляет нас со следующим питоном:

mincount = min(count)
maxcount = max(count)
xoffset = log(mincount)
gradient = (maxsize-minsize)/(log(maxcount)-log(mincount))
for c in count:
    x = log(c)-xoffset
    size = gradient * x + minsize

Если вы хотите убедиться, что минимальное количество всегда равно как минимум 1, замените первую строку на:

mincount = min(count+[1])

который добавляет 1 к списку счетчиков перед выполнением мин. То же самое касается обеспечения того, чтобы maxcount всегда был не менее 1. Таким образом, ваш окончательный код, как указано выше:

from math import log
count = [1, 3, 5, 4, 7, 5, 10, 6]
def logdist(count, maxsize=1.75, minsize=.75):
    countdist = []
    mincount = min(count+[1])
    maxcount = max(count+[1])
    xoffset = log(mincount)
    gradient = (maxsize-minsize)/(log(maxcount)-log(mincount))
    for c in count:
        x = log(c)-xoffset
        size = gradient * x + minsize
        countdist.append({'count': c, 'size': round(size, 3)})
    return countdist

что у вас есть, так это то, что у вас есть теги, количество которых от MIN до MAX; проблему порога здесь можно игнорировать, потому что она сводится к установке каждого счетчика ниже порога в пороговое значение и взятию минимума и максимума только после этого.

Вы хотите сопоставить количество тегов с «весами», но «логарифмическим способом», что в основном означает (насколько я понимаю) следующее. Во-первых, теги со значением count MAX получают вес max_weight (в вашем примере 1,75):

weight(MAX) = max_weight

Во-вторых, теги со значением MIN получают вес min_weight (в вашем примере 0,75):

weight(MIN) = min_weight

Наконец, считается, что когда ваш счет уменьшается на 1, вес умножается на константу K ‹ 1, что указывает на крутизну кривой:

weight(x) = weight(x + 1) * K

Решая это, мы получаем:

weight(x) = weight_max * (K ^ (MAX - x))

Обратите внимание, что при x = MAX показатель степени равен нулю, а множимое справа становится равным 1.

Теперь у нас есть дополнительное требование, что вес (MIN) = min_weight, и мы можем решить:

weight_min = weight_max * (K ^ (MAX - MIN))

из которого мы получаем

K ^ (MAX - MIN) = weight_min / weight_max

и логарифмирование с обеих сторон

(MAX - MIN) ln K = ln weight_min - ln weight_max

i.e.

ln K = (ln weight_min - ln weight_max) / (MAX - MIN)

Правая часть отрицательна, как и требовалось, поскольку K ‹ 1. Тогда

K = exp((ln weight_min - ln weight_max) / (MAX - MIN))

Итак, теперь у вас есть формула для расчета K. После этого вы просто применяете любое количество x между MIN и MAX:

weight(x) = max_weight * (K ^ (MAX - x))

Готово.

В логарифмическом масштабе вы просто строите логарифм чисел линейно (другими словами, представьте, что вы строите линейный график, но сначала берете логарифм чисел).

Проблема нуля не может быть решена аналитически — вы должны выбрать минимальный порядок величины для вашей шкалы, и независимо от того, что вы никогда не сможете достичь нуля. Если вы хотите отобразить что-то на нуле, вы можете произвольно присвоить ему минимальный порядок масштаба или опустить его.

У меня нет точного ответа, но я думаю, что вы хотите найти Линеаризация экспоненциальных данных. Начните с расчета уравнения линии, проходящей через точки, и возьмите журнал обеих частей этого уравнения.