262 lines
8.8 KiB
Python
262 lines
8.8 KiB
Python
import math
|
|
from operator import attrgetter, itemgetter
|
|
|
|
from django.db import migrations, models
|
|
from django.db.models import Count, OuterRef, Subquery
|
|
from django.db.models.functions import Coalesce
|
|
from django.utils import timezone
|
|
|
|
|
|
def tie_ranker(iterable, key=attrgetter("points")):
|
|
rank = 0
|
|
delta = 1
|
|
last = None
|
|
buf = []
|
|
for item in iterable:
|
|
new = key(item)
|
|
if new != last:
|
|
for _ in buf:
|
|
yield rank + (delta - 1) / 2.0
|
|
rank += delta
|
|
delta = 0
|
|
buf = []
|
|
delta += 1
|
|
buf.append(item)
|
|
last = key(item)
|
|
for _ in buf:
|
|
yield rank + (delta - 1) / 2.0
|
|
|
|
|
|
def rational_approximation(t):
|
|
# Abramowitz and Stegun formula 26.2.23.
|
|
# The absolute value of the error should be less than 4.5 e-4.
|
|
c = [2.515517, 0.802853, 0.010328]
|
|
d = [1.432788, 0.189269, 0.001308]
|
|
numerator = (c[2] * t + c[1]) * t + c[0]
|
|
denominator = ((d[2] * t + d[1]) * t + d[0]) * t + 1.0
|
|
return t - numerator / denominator
|
|
|
|
|
|
def normal_CDF_inverse(p):
|
|
assert 0.0 < p < 1
|
|
|
|
# See article above for explanation of this section.
|
|
if p < 0.5:
|
|
# F^-1(p) = - G^-1(p)
|
|
return -rational_approximation(math.sqrt(-2.0 * math.log(p)))
|
|
else:
|
|
# F^-1(p) = G^-1(1-p)
|
|
return rational_approximation(math.sqrt(-2.0 * math.log(1.0 - p)))
|
|
|
|
|
|
def WP(RA, RB, VA, VB):
|
|
return (math.erf((RB - RA) / math.sqrt(2 * (VA * VA + VB * VB))) + 1) / 2.0
|
|
|
|
|
|
def recalculate_ratings(
|
|
old_rating, old_volatility, actual_rank, times_rated, is_disqualified
|
|
):
|
|
# actual_rank: 1 is first place, N is last place
|
|
# if there are ties, use the average of places (if places 2, 3, 4, 5 tie, use 3.5 for all of them)
|
|
|
|
N = len(old_rating)
|
|
new_rating = old_rating[:]
|
|
new_volatility = old_volatility[:]
|
|
if N <= 1:
|
|
return new_rating, new_volatility
|
|
|
|
ranking = list(range(N))
|
|
ranking.sort(key=old_rating.__getitem__, reverse=True)
|
|
|
|
ave_rating = float(sum(old_rating)) / N
|
|
sum1 = sum(i * i for i in old_volatility) / N
|
|
sum2 = sum((i - ave_rating) ** 2 for i in old_rating) / (N - 1)
|
|
CF = math.sqrt(sum1 + sum2)
|
|
|
|
for i in range(N):
|
|
ERank = 0.5
|
|
for j in range(N):
|
|
ERank += WP(
|
|
old_rating[i], old_rating[j], old_volatility[i], old_volatility[j]
|
|
)
|
|
|
|
EPerf = -normal_CDF_inverse((ERank - 0.5) / N)
|
|
APerf = -normal_CDF_inverse((actual_rank[i] - 0.5) / N)
|
|
PerfAs = old_rating[i] + CF * (APerf - EPerf)
|
|
Weight = 1.0 / (1 - (0.42 / (times_rated[i] + 1) + 0.18)) - 1.0
|
|
if old_rating[i] > 2500:
|
|
Weight *= 0.8
|
|
elif old_rating[i] >= 2000:
|
|
Weight *= 0.9
|
|
|
|
Cap = 150.0 + 1500.0 / (times_rated[i] + 2)
|
|
|
|
new_rating[i] = (old_rating[i] + Weight * PerfAs) / (1.0 + Weight)
|
|
|
|
if abs(old_rating[i] - new_rating[i]) > Cap:
|
|
if old_rating[i] < new_rating[i]:
|
|
new_rating[i] = old_rating[i] + Cap
|
|
else:
|
|
new_rating[i] = old_rating[i] - Cap
|
|
|
|
if times_rated[i] == 0:
|
|
new_volatility[i] = 385
|
|
else:
|
|
new_volatility[i] = math.sqrt(
|
|
((new_rating[i] - old_rating[i]) ** 2) / Weight
|
|
+ (old_volatility[i] ** 2) / (Weight + 1)
|
|
)
|
|
|
|
if is_disqualified[i]:
|
|
# DQed users can manipulate TopCoder ratings to get higher volatility in order to increase their rating
|
|
# later on, prohibit this by ensuring their volatility never increases in this situation
|
|
new_volatility[i] = min(new_volatility[i], old_volatility[i])
|
|
|
|
# try to keep the sum of ratings constant
|
|
adjust = float(sum(old_rating) - sum(new_rating)) / N
|
|
new_rating = list(map(adjust.__add__, new_rating))
|
|
# inflate a little if we have to so people who placed first don't lose rating
|
|
best_rank = min(actual_rank)
|
|
for i in range(N):
|
|
if (
|
|
abs(actual_rank[i] - best_rank) <= 1e-3
|
|
and new_rating[i] < old_rating[i] + 1
|
|
):
|
|
new_rating[i] = old_rating[i] + 1
|
|
return list(map(int, map(round, new_rating))), list(
|
|
map(int, map(round, new_volatility))
|
|
)
|
|
|
|
|
|
def tc_rate_contest(contest, Rating, Profile):
|
|
rating_subquery = Rating.objects.filter(user=OuterRef("user"))
|
|
rating_sorted = rating_subquery.order_by("-contest__end_time")
|
|
users = (
|
|
contest.users.order_by("is_disqualified", "-score", "cumtime", "tiebreaker")
|
|
.annotate(
|
|
submissions=Count("submission"),
|
|
last_rating=Coalesce(Subquery(rating_sorted.values("rating")[:1]), 1200),
|
|
volatility=Coalesce(Subquery(rating_sorted.values("volatility")[:1]), 535),
|
|
times=Coalesce(
|
|
Subquery(
|
|
rating_subquery.order_by()
|
|
.values("user_id")
|
|
.annotate(count=Count("id"))
|
|
.values("count")
|
|
),
|
|
0,
|
|
),
|
|
)
|
|
.exclude(user_id__in=contest.rate_exclude.all())
|
|
.filter(virtual=0)
|
|
.values(
|
|
"id",
|
|
"user_id",
|
|
"score",
|
|
"cumtime",
|
|
"tiebreaker",
|
|
"is_disqualified",
|
|
"last_rating",
|
|
"volatility",
|
|
"times",
|
|
)
|
|
)
|
|
if not contest.rate_all:
|
|
users = users.filter(submissions__gt=0)
|
|
if contest.rating_floor is not None:
|
|
users = users.exclude(last_rating__lt=contest.rating_floor)
|
|
if contest.rating_ceiling is not None:
|
|
users = users.exclude(last_rating__gt=contest.rating_ceiling)
|
|
|
|
users = list(users)
|
|
participation_ids = list(map(itemgetter("id"), users))
|
|
user_ids = list(map(itemgetter("user_id"), users))
|
|
is_disqualified = list(map(itemgetter("is_disqualified"), users))
|
|
ranking = list(tie_ranker(users, key=itemgetter("score", "cumtime", "tiebreaker")))
|
|
old_rating = list(map(itemgetter("last_rating"), users))
|
|
old_volatility = list(map(itemgetter("volatility"), users))
|
|
times_ranked = list(map(itemgetter("times"), users))
|
|
rating, volatility = recalculate_ratings(
|
|
old_rating, old_volatility, ranking, times_ranked, is_disqualified
|
|
)
|
|
|
|
now = timezone.now()
|
|
ratings = [
|
|
Rating(
|
|
user_id=i,
|
|
contest=contest,
|
|
rating=r,
|
|
volatility=v,
|
|
last_rated=now,
|
|
participation_id=p,
|
|
rank=z,
|
|
)
|
|
for i, p, r, v, z in zip(
|
|
user_ids, participation_ids, rating, volatility, ranking
|
|
)
|
|
]
|
|
|
|
Rating.objects.bulk_create(ratings)
|
|
|
|
Profile.objects.filter(
|
|
contest_history__contest=contest, contest_history__virtual=0
|
|
).update(
|
|
rating=Subquery(
|
|
Rating.objects.filter(user=OuterRef("id"))
|
|
.order_by("-contest__end_time")
|
|
.values("rating")[:1]
|
|
)
|
|
)
|
|
|
|
|
|
# inspired by rate_all_view
|
|
def rate_tc(apps, schema_editor):
|
|
Contest = apps.get_model("judge", "Contest")
|
|
Rating = apps.get_model("judge", "Rating")
|
|
Profile = apps.get_model("judge", "Profile")
|
|
|
|
with schema_editor.connection.cursor() as cursor:
|
|
cursor.execute("TRUNCATE TABLE `%s`" % Rating._meta.db_table)
|
|
Profile.objects.update(rating=None)
|
|
for contest in Contest.objects.filter(
|
|
is_rated=True, end_time__lte=timezone.now()
|
|
).order_by("end_time"):
|
|
tc_rate_contest(contest, Rating, Profile)
|
|
|
|
|
|
# inspired by rate_all_view
|
|
def rate_elo_mmr(apps, schema_editor):
|
|
Rating = apps.get_model("judge", "Rating")
|
|
Profile = apps.get_model("judge", "Profile")
|
|
|
|
with schema_editor.connection.cursor() as cursor:
|
|
cursor.execute("TRUNCATE TABLE `%s`" % Rating._meta.db_table)
|
|
Profile.objects.update(rating=None)
|
|
# Don't populate Rating
|
|
|
|
|
|
class Migration(migrations.Migration):
|
|
|
|
dependencies = [
|
|
("judge", "0117_auto_20211209_0612"),
|
|
]
|
|
|
|
operations = [
|
|
migrations.RunPython(migrations.RunPython.noop, rate_tc, atomic=True),
|
|
migrations.AddField(
|
|
model_name="rating",
|
|
name="mean",
|
|
field=models.FloatField(verbose_name="raw rating"),
|
|
),
|
|
migrations.AddField(
|
|
model_name="rating",
|
|
name="performance",
|
|
field=models.FloatField(verbose_name="contest performance"),
|
|
),
|
|
migrations.RemoveField(
|
|
model_name="rating",
|
|
name="volatility",
|
|
field=models.IntegerField(verbose_name="volatility"),
|
|
),
|
|
migrations.RunPython(rate_elo_mmr, migrations.RunPython.noop, atomic=True),
|
|
]
|