Используйте Flask для быстрого создания системы рекомендаций игр Steam.

Python

Некоторые люди зависимы от Douyin, в то время как другие зависимы от Zhihu.Система рекомендаций теперь влияет и даже контролирует жизнь людей. В этой статье мы начнем с простейшего алгоритма и процесса, а затем воспользуемся Flask и дроком для быстрого создания системы рекомендаций игр Steam.

Архитектура системы рекомендаций

Перед началом разработки нам нужно спроектировать архитектуру моей рекомендательной системы, как показано на следующем рисунке:

Можно разделить на три части:

  • gorse: gorseЭто автономная система рекомендаций, которая отправляет в нее записи о покупках игр пользователями, и она может автоматически обучать модель и генерировать список рекомендаций игр;
  • Flask: веб-служба, написанная с помощью Flask, отвечает за вход пользователя в систему, запрос информации об инвентаре пользователя из Steam, отправку информации об инвентаре в gorse, а также извлечение и отправку результатов;
  • Steam: Предоставьте информацию об инвентаре через API и предоставьте изображение обложки игры.

Эта система рекомендаций игр Steam была развернута дляsteamlens.gorse.io, если у вас есть учетная запись Steam и способ доступа к сообществу Steam (вы знаете какой), вы можете попробовать эффект персонализированной рекомендации. Код также с открытым исходным кодомGitHubЕсли у вас есть VPS, который может получить доступ к серверу сообщества Steam, вы можете попробовать развернуть его самостоятельно.

Создайте рекомендуемый системный сервер

Установить

Сначала нам нужно установить серверную часть рекомендательной системы.gorse, если локаль Go уже установлена, будет$GOBINдобавить переменную окружения$PATH, то вы можете установить его напрямую с помощью следующей команды:

$ go get github.com/zhenghaoz/gorse/...

подготовка данных

Все основано на данных, но, к счастью, другие поделились онлайнНабор данных SteamСейчас объем исходных данных очень большой, для удобства демонстрации он сэмплирован.games.csv. Создаем папку и затем скачиваем данные:

$ mkdir SteamLens
$ cd SteamLens
$ wget http://cdn.sine-x.com/backups/games.csv
...
$ head games.csv
76561197960272226,10,505
76561197960272226,20,0
76561197960272226,30,0
76561197960272226,40,0
76561197960272226,50,0
76561197960272226,60,0
76561197960272226,70,0
76561197960272226,130,0
76561197960272226,80,0
76561197960272226,100,0

Можно обнаружить, что данные имеют три столбца, а именно: пользователи, игры и продолжительность.

тестовая модель

Прежде чем создавать рекомендательный сервис, вам нужно выбрать наиболее подходящий рекомендательный алгоритм.Gorse предоставляет различные модели для оценки, и вы можете запуститьgorse test -hили просмотретьонлайн-документацияУзнайте, как использовать. Наш набор данных принадлежитНеявная обратная связь с весом (продолжительность игры),в соответствии скаждая модельДля поддерживаемых входов можно использовать четыре модели:item-pop,knn_implicit,bprиwrmf.

Сначала протестируйте неперсонализированные рекомендации в качестве эталона:

$ gorse test item-pop --load-csv games.csv --csv-sep ',' --eval-precision --eval-recall --eval-ndcg --eval-map --eval-mrr
...
+--------------+----------+----------+----------+----------+----------+----------------------+
|              |  FOLD 1  |  FOLD 2  |  FOLD 3  |  FOLD 4  |  FOLD 5  |         MEAN         |
+--------------+----------+----------+----------+----------+----------+----------------------+
| Precision@10 | 0.080942 | 0.080655 | 0.080253 | 0.078880 | 0.078248 | 0.079796(±0.001548)  |
| Recall@10    | 0.308894 | 0.310532 | 0.312299 | 0.305665 | 0.308428 | 0.309163(±0.003498)  |
| NDCG@10      | 0.211919 | 0.209796 | 0.209004 | 0.209945 | 0.210466 | 0.210226(±0.001693)  |
| MAP@10       | 0.133684 | 0.132018 | 0.130520 | 0.133500 | 0.135297 | 0.133004(±0.002484)  |
| MRR@10       | 0.247601 | 0.242664 | 0.240176 | 0.244244 | 0.241920 | 0.243321(±0.004280)  |
+--------------+----------+----------+----------+----------+----------+----------------------+
2019/11/07 09:56:51 Complete cross validation (22.037387763s)

Проверьте неявный KNN:

$ gorse test knn_implicit --load-csv games.csv --csv-sep ',' --eval-precision --eval-recall --eval-ndcg --eval-map --eval-mrr
...
+--------------+----------+----------+----------+----------+----------+----------------------+
|              |  FOLD 1  |  FOLD 2  |  FOLD 3  |  FOLD 4  |  FOLD 5  |         MEAN         |
+--------------+----------+----------+----------+----------+----------+----------------------+
| Precision@10 | 0.150892 | 0.153211 | 0.147429 | 0.152162 | 0.150013 | 0.150742(±0.003312)  |
| Recall@10    | 0.529160 | 0.546523 | 0.533619 | 0.543382 | 0.533702 | 0.537277(±0.009245)  |
| NDCG@10      | 0.528442 | 0.546386 | 0.529590 | 0.545167 | 0.530433 | 0.536004(±0.010383)  |
| MAP@10       | 0.451220 | 0.469989 | 0.453748 | 0.468641 | 0.453865 | 0.459493(±0.010497)  |
| MRR@10       | 0.635610 | 0.656008 | 0.636238 | 0.658769 | 0.636045 | 0.644534(±0.014235)  |
+--------------+----------+----------+----------+----------+----------+----------------------+
2019/11/07 09:59:14 Complete cross validation (1m4.169339752s)

Протестируйте BPR еще раз:

$ gorse test bpr --load-csv games.csv --csv-sep ',' --eval-precision --eval-recall --eval-ndcg --eval-map --eval-mrr
...
+--------------+----------+----------+----------+----------+----------+----------------------+
|              |  FOLD 1  |  FOLD 2  |  FOLD 3  |  FOLD 4  |  FOLD 5  |         MEAN         |
+--------------+----------+----------+----------+----------+----------+----------------------+
| Precision@10 | 0.127123 | 0.128440 | 0.129396 | 0.124914 | 0.126719 | 0.127318(±0.002405)  |
| Recall@10    | 0.502971 | 0.511863 | 0.515385 | 0.503914 | 0.505500 | 0.507926(±0.007458)  |
| NDCG@10      | 0.434958 | 0.421336 | 0.427279 | 0.405582 | 0.424385 | 0.422708(±0.017126)  |
| MAP@10       | 0.350960 | 0.332219 | 0.336659 | 0.313238 | 0.337824 | 0.334180(±0.020942)  |
| MRR@10       | 0.495087 | 0.466407 | 0.477137 | 0.447885 | 0.475176 | 0.472338(±0.024453)  |
+--------------+----------+----------+----------+----------+----------+----------------------+
2019/11/07 10:01:51 Complete cross validation (56.85278659s)

Наконец, протестируйте WRMF, так как значение продолжительности игры очень велико, нам нужно задать небольшой весовой коэффициент.\alpha=0.01:

$ gorse test wrmf --load-csv games.csv --csv-sep ',' --eval-precision --eval-recall --eval-ndcg --eval-map --eval-mrr --set-alpha 0.001
...
+--------------+----------+----------+----------+----------+----------+----------------------+
|              |  FOLD 1  |  FOLD 2  |  FOLD 3  |  FOLD 4  |  FOLD 5  |         MEAN         |
+--------------+----------+----------+----------+----------+----------+----------------------+
| Precision@10 | 0.145834 | 0.148021 | 0.147034 | 0.146564 | 0.143163 | 0.146123(±0.002960)  |
| Recall@10    | 0.524673 | 0.533390 | 0.533113 | 0.535772 | 0.525784 | 0.530546(±0.005873)  |
| NDCG@10      | 0.499655 | 0.504544 | 0.506967 | 0.513855 | 0.501728 | 0.505350(±0.008505)  |
| MAP@10       | 0.415299 | 0.419840 | 0.423166 | 0.431339 | 0.421243 | 0.422177(±0.009161)  |
| MRR@10       | 0.592257 | 0.592858 | 0.596109 | 0.610589 | 0.590023 | 0.596367(±0.014222)  |
+--------------+----------+----------+----------+----------+----------+----------------------+
2019/11/07 10:06:52 Complete cross validation (3m52.912709237s)

В настоящее время (мы фактически не отрегулировали параметры хорошо), алгоритм KNN выполнил лучшее в нашем наборе данных, а скорость была удовлетворительной, поэтому мы выбрали KNN в качестве рекомендуемого алгоритма для этого случая. Никакая рекомендация не обязательно связана с другими алгоритмами, лучший алгоритм зависит от характеристик данных набора данных, например, лучшая модель на Movielens 100k - WRMF вместо KNN.

Импорт данных

После выбора модели импортируем данные во встроенную базу данных gorse и создаем папкуdataДля существующих данных импортируйте данные вdata/gorse.dbсередина:

$ mkdir data
$ gorse import-feedback data/gorse.db games.csv --sep ','

запустить сервер

Затем создайте файл конфигурации для рекомендуемой службы.config/gorse.toml, вам нужно установить адрес прослушивания сервера, порт, местоположение файла базы данных, некоторую тривиальную рекомендуемую конфигурацию, неявный KNN не нуждается в суперпараметрах, поэтому[params]Оставить пустым.

# This section declares settings for the server.
[server]
host = "0.0.0.0"        # server host
port = 8080             # server port

# This section declares setting for the database.
[database]
file = "data/gorse.db"  # database file

# This section declares settings for recommendation.
[recommend]
model = "knn_implicit"  # recommendation model
cache_size = 100        # the number of cached recommendations
update_threshold = 10   # update model when more than 10 ratings are added
check_period = 1        # check for update every one minute
similarity = "implicit" # similarity metric for neighbors

# This section declares hyperparameters for the recommendation model.
[params]

После сохранения файла конфигурации запустите сервер рекомендаций:

$ gorse serve -c config/gorse.toml
...
2019/11/07 16:45:05 update recommends
2019/11/07 16:47:02 update neighbors by implicit

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

Протестируйте рекомендуемый интерфейс

Мы можем использовать предоставленный утесникRESTful APIЧтобы получить рекомендуемые результаты:

$ curl http://127.0.0.1:8080/recommends/76561197960272226?number=10
[
 {
  "ItemId": 4540,
  "Score": 23.479386364078838
 },
 ...
 {
  "ItemId": 57300,
  "Score": 22.156954153653245
 }
]

Мы получили 10 рекомендаций, включая идентификаторы игр и оценки рекомендаций.

Создайте интерфейсный сервер отображения

подать заявку на ключ

Нам нужно подключить учетную запись Steam пользователя, чтобы получить инвентарные игры, поэтому для этого требуется вход пользователя и доступ к«Зарегистрируйте ключ веб-API Steam»Страница запрашивает ключ API в Steam для вызова API,

Среда разработки Flask

Затем вы можете подготовить пакеты Python, необходимые для разработки Flask, которые необходимо установить последовательно:

$ pip install Flask
$ pip install Flask-OpenID
$ pip install Flask-SQLAlchemy
$ pip install uWSGI

Мы можем создать папку steamlens под SteamLens для хранения программного кода Flask:

$ mkdir steamlens

титульная страница

Дизайн интерфейса не является предметом этой статьи, можно увидеть конкретный код HTML-шаблона.steamlens/templates, статические ресурсы видныsteamlens/static, в репозитории представлены две страницы:

шаблон эффект данные
page_gallery.jinja2 Показать список игр current_time: время,title: заглавие,items: список игр,nickname: Поддержка псевдонимов
page_app.jinja2 Показать игру и список похожих игр current_time: время,item_id: Игра ID,title: заглавие,items: похожий список,nickname: псевдоним пользователя

Заполните файл конфигурации

Прежде чем писать код бэкенда, заполните информацию о конфигурации:

# Configuration for gorse
GORSE_API_URI = 'http://127.0.0.1:8080'
GORSE_NUM_ITEMS = 30

# Configuration for SQL
SQLALCHEMY_DATABASE_URI = 'sqlite:///../data/steamlens.db'
SQLALCHEMY_TRACK_MODIFICATIONS = False

# Configuration for OpenID
OPENID_STIRE = '../data/openid_store'
SECRET_KEY = 'STEAM_API_KEY'

Не забудьте заменить STEAM_API_KEY своим ключом Steam..

Логин пользователя

Сначала пишем базовый фреймворк и функцию для подключения к Steam, файлы находятся по адресуsteamlens/app.py, функция программы следующая:

  1. Создайте объект приложения Flask из переменных средыSTEAMLENS_SETTINGSпрочитать конфигурацию;
  2. Создайте объект OpenID для подключения к аутентификации Steam;
  3. Создайте объект SQLAlchemy для подключения к базе данных;
  4. Когда пользователь входит в систему, имя пользователя и идентификатор получаются и сохраняются в базе данных, а список игр в инвентаре отправляется на сервер gorse.
import json
import os.path
import re
from datetime import datetime
from urllib.parse import urlencode
from urllib.request import urlopen

import requests
from flask import Flask, render_template, redirect, session, g
from flask_openid import OpenID
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config.from_envvar('STEAMLENS_SETTINGS')

oid = OpenID(app, os.path.join(os.path.dirname(__file__), app.config['OPENID_STIRE']))
db = SQLAlchemy(app)

#################
# Steam Service #
#################

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    steam_id = db.Column(db.String(40))
    nickname = db.Column(db.String(80))

    @staticmethod
    def get_or_create(steam_id):
        rv = User.query.filter_by(steam_id=steam_id).first()
        if rv is None:
            rv = User()
            rv.steam_id = steam_id
            db.session.add(rv)
        return rv


@app.route("/login")
@oid.loginhandler
def login():
    if g.user is not None:
        return redirect(oid.get_next_url())
    else:
        return oid.try_login("http://steamcommunity.com/openid")


@app.route('/logout')
def logout():
    session.pop('user_id', None)
    return redirect('/pop')


@app.before_request
def before_request():
    g.user = None
    if 'user_id' in session:
        g.user = User.query.filter_by(id=session['user_id']).first()


@oid.after_login
def new_user(resp):
    _steam_id_re = re.compile('steamcommunity.com/openid/id/(.*?)$')
    match = _steam_id_re.search(resp.identity_url)
    g.user = User.get_or_create(match.group(1))
    steamdata = get_user_info(g.user.steam_id)
    g.user.nickname = steamdata['personaname']
    db.session.commit()
    session['user_id'] = g.user.id
    # Add games to gorse
    games = get_owned_games(g.user.steam_id)
    data = [{'UserId': int(g.user.steam_id), 'ItemId': int(v['appid']), 'Feedback': float(v['playtime_forever'])} for v in games]
    headers = {"Content-Type": "application/json"}
    requests.put('http://127.0.0.1:8080/feedback', data=json.dumps(data), headers=headers)
    return redirect(oid.get_next_url())


def get_user_info(steam_id):
    options = {
        'key': app.secret_key,
        'steamids': steam_id
    }
    url = 'http://api.steampowered.com/ISteamUser/' \
          'GetPlayerSummaries/v0001/?%s' % urlencode(options)
    rv = json.load(urlopen(url))
    return rv['response']['players']['player'][0] or {}


def get_owned_games(steam_id):
    options = {
        'key': app.secret_key,
        'steamid': steam_id,
        'format': 'json'
    }
    url = 'http://api.steampowered.com/IPlayerService/GetOwnedGames/v0001/?%s' % urlencode(options)
    rv = json.load(urlopen(url))
    return rv['response']['games']


# Create tables if not exists.
db.create_all()

Рекомендуемый дисплей

затем вsteamlens/app.pyДобавьте рекомендуемую функцию отображения в дрокRESTful APIчтобы получать популярные игры, случайные игры, персональные рекомендации и игры, похожие на игру.

#######################
# Recommender Service #
#######################

@app.context_processor
def inject_current_time():
    return {'current_time': datetime.utcnow()}


@app.route('/')
def index():
    return redirect('/pop')


@app.route('/pop')
def pop():
    # Get nickname
    nickname = None
    if g.user:
        nickname = g.user.nickname
    # Get items
    r = requests.get('%s/popular?number=%d' % (app.config['GORSE_API_URI'], app.config['GORSE_NUM_ITEMS']))
    items = [v['ItemId'] for v in r.json()]
    # Render page
    return render_template('page_gallery.jinja2', title='Popular Games', items=items, nickname=nickname)


@app.route('/random')
def random():
    # Get nickname
    nickname = None
    if g.user:
        nickname = g.user.nickname
    # Get items
    r = requests.get('%s/random?number=%d' % (app.config['GORSE_API_URI'], app.config['GORSE_NUM_ITEMS']))
    items = [v['ItemId'] for v in r.json()]
    # Render page
    return render_template('page_gallery.jinja2', title='Random Games', items=items, nickname=nickname)


@app.route('/recommend')
def recommend():
    # Check login
    if g.user is None:
        return render_template('page_gallery.jinja2', title='Please login first', items=[])
    # Get items
    r = requests.get('%s/recommends/%s?number=%s' %
                     (app.config['GORSE_API_URI'], g.user.steam_id, app.config['GORSE_NUM_ITEMS']))
    # Render page
    if r.status_code == 200:
        items = [v['ItemId'] for v in r.json()]
        return render_template('page_gallery.jinja2', title='Recommended Games', items=items, nickname=g.user.nickname)
    return render_template('page_gallery.jinja2', title='Generating Recommended Games...', items=[], nickname=g.user.nickname)


@app.route('/item/<int:app_id>')
def item(app_id: int):
    # Get nickname
    nickname = None
    if g.user:
        nickname = g.user.nickname
    # Get items
    r = requests.get('%s/neighbors/%d?number=%d' %
                     (app.config['GORSE_API_URI'], app_id, app.config['GORSE_NUM_ITEMS']))
    items = [v['ItemId'] for v in r.json()]
    # Render page
    return render_template('page_app.jinja2', item_id=app_id, title='Similar Games', items=items, nickname=nickname)


@app.route('/user')
def user():
    # Check login
    if g.user is None:
        return render_template('page_gallery.jinja2', title='Please login first', items=[])
    # Get items
    r = requests.get('%s/user/%s' % (app.config['GORSE_API_URI'], g.user.steam_id))
    # Render page
    if r.status_code == 200:
        items = [v['ItemId'] for v in r.json()]
        return render_template('page_gallery.jinja2', title='Owned Games', items=items, nickname=g.user.nickname)
    return render_template('page_gallery.jinja2', title='Synchronizing Owned Games ...', items=[], nickname=g.user.nickname)

запустить сервер

Мы используем uWSGI для запуска сервера Flask, поэтому он должен находиться в самой внешней папке.SteamLensСоздайте uwsgi.ini в:

[uwsgi]

# Bind to the specified UNIX/TCP socket using default protocol
socket=0.0.0.0:5000

# Point to the main directory of the Web Site
chdir=/path/to/SteamLens/steamlens/

# Python startup file
wsgi-file=app.py

# The application variable of Python Flask Core Oject 
callable=app

# The maximum numbers of Processes
processes=1

# The maximum numbers of Threads
threads=2

# Set internal buffer size 
buffer-size=8192

Не забудьте изменить chdir на путь, по которому находится папка SteamLens/steamlens.. Наконец, выполните следующую команду, чтобы запустить приложение Flask:

$ STEAMLENS_SETTINGS ../config/steamlens.cfg uwsgi --ini uwsgi.ini

может получить доступsteamlens.gorse.io/Ознакомьтесь с онлайн-демонстрацией, войдите в систему и подождите немного, чтобы получить персональные рекомендации. Рекомендуемые автором результаты следующие:

Автор любит FPS-игры, и он мне порекомендовал много FPS-игр. Однако можно обнаружить, что рекомендуемые игры относительно старые, потому что набор данных, используемый в проекте, относится к 2013 г. Поскольку Steam обновил свою политику конфиденциальности, в настоящее время невозможно получить пользовательский инвентарь без авторизации пользователя.

Категории