Auto-Tinder - 训练 AI 帮你刷 Tinder（约会应用）

Auto-tinder 旨在利用 TensorFlow（一种机器学习框架）和 Python3 训练一个 API（应用程序编程接口），该 API 能够学习你的兴趣，并自动为你完成 Tinder（约会应用）的滑动匹配游戏。

在这份文档中，我将介绍创建 Auto-tinder 所需的以下步骤：

• 分析 Tinder 网页以找出 Tinder 进行的内部 API（应用程序编程接口）调用，在 Postman（API 测试工具）中重建这些 API 调用并分析其内容
• 用 Python 构建一个 API（应用程序编程接口）包装类，该类使用 Tinder API（应用程序编程接口）来执行喜欢/不喜欢/匹配等操作
• 下载一批附近人物的图片
• 编写一个简单的鼠标点击分类器来为我们的图片打标签
• 开发一个预处理器，利用 TensorFlow 目标检测 API（应用程序编程接口）仅裁剪出图片中的人物
• 重新训练 InceptionV3（一种深度卷积神经网络），使其在我们的分类数据上进行学习
• 结合分类器和 Tinder API（应用程序编程接口）包装类来为我们玩 Tinder

第 0 步：动机与免责声明

Auto-tinder 是一个纯粹为了娱乐和教育目的而创建的概念项目。它绝不应被滥用去伤害任何人或骚扰平台。Auto-tinder 脚本不应与您的 Tinder 个人资料配合使用，因为它们肯定违反了 Tinder 的服务条款（Terms of Service）。

我编写这段软件主要有两个主要原因：

1. 因为我能做到，而且创造它很有趣 :)
2. 我想弄清楚 AI 是否真的能够学习我对异性的偏好，并成为我可靠的左右滑动伴侣。
3. （纯属虚构的理由：我是个懒人，为什么不投入 15 小时编写 Auto-tinder + 5 小时标注所有图片，从而节省我自己实际刷 Tinder 的几个小时呢？对我来说这听起来是一笔划算的交易！）

第一步：分析 Tinder API (应用程序接口)

第一步是找出 Tinder 应用程序如何与其后端服务器通信。由于 Tinder 提供了其门户的网页版本，这很简单，只需访问 tinder.com，打开 Chrome DevTools 并快速查看网络协议即可。

上图显示的内容来自当 tinder.com 主页加载时发出的对 https://api.gotinder.com/v2/recs/core 的请求。显然，Tinder 拥有某种内部 API (应用程序接口)，用于在前端和后端之间进行通信。

通过分析 /recs/core 的内容，可以清楚地看到这个 API 端点返回了附近用户个人资料列表。

数据包含（除许多其他字段外）以下数据：

{
    "meta": {
        "status": 200
    },
    "data": {
        "results": [
            {
                "type": "user",
                "user": {
                 "_id": "4adfwe547s8df64df",
                    "bio": "19y.",
                    "birth_date": "1997-17-06T18:21:44.654Z",
                    "name": "Anna",
                    "photos": [
                        {
                            "id": "879sdfert-lskdföj-8asdf879-987sdflkj",
                            "crop_info": {
                                "user": {
                                    "width_pct": 1,
                                    "x_offset_pct": 0,
                                    "height_pct": 0.8,
                                    "y_offset_pct": 0.08975463
                                },
                                "algo": {
                                    "width_pct": 0.45674357,
                                    "x_offset_pct": 0.984341657,
                                    "height_pct": 0.234165403,
                                    "y_offset_pct": 0.78902343
                                },
                                "processed_by_bullseye": true,
                                "user_customized": false
                            },
                            "url": "https://images-ssl.gotinder.com/4adfwe547s8df64df/original_879sdfert-lskdföj-8asdf879-987sdflkj.jpeg",
                            "processedFiles": [
                                {
                                    "url": "https://images-ssl.gotinder.com/4adfwe547s8df64df/640x800_879sdfert-lskdföj-8asdf879-987sdflkj.jpg",
                                    "height": 800,
                                    "width": 640
                                },
                                {
                                    "url": "https://images-ssl.gotinder.com/4adfwe547s8df64df/320x400_879sdfert-lskdföj-8asdf879-987sdflkj.jpg",
                                    "height": 400,
                                    "width": 320
                                },
                                {
                                    "url": "https://images-ssl.gotinder.com/4adfwe547s8df64df/172x216_879sdfert-lskdföj-8asdf879-987sdflkj.jpg",
                                    "height": 216,
                                    "width": 172
                                },
                                {
                                    "url": "https://images-ssl.gotinder.com/4adfwe547s8df64df/84x106_879sdfert-lskdföj-8asdf879-987sdflkj.jpg",
                                    "height": 106,
                                    "width": 84
                                }
                            ],
                            "last_update_time": "2019-10-03T16:18:30.532Z",
                            "fileName": "879sdfert-lskdföj-8asdf879-987sdflkj.webp",
                            "extension": "jpg,webp",
                            "webp_qf": [
                                75
                            ]
                        }
                    ],
                    "gender": 1,
                    "jobs": [],
                    "schools": [],
                    "show_gender_on_profile": false
                },
                "facebook": {
                    "common_connections": [],
                    "connection_count": 0,
                    "common_interests": []
                },
                "spotify": {
                    "spotify_connected": false
                },
                "distance_mi": 1,
                "content_hash": "slkadjfiuwejsdfuzkejhrsdbfskdzufiuerwer",
                "s_number": 9876540657341,
                "teaser": {
                    "string": ""
                },
                "teasers": [],
                "snap": {
                    "snaps": []
                }
            }
        ]
    }
}
           

这里有几点非常有趣 （注意我已更改所有数据以不侵犯此人的隐私）：

• 所有图片均可公开访问。如果你复制图片 URL 并在无痕窗口中打开它，它仍然会立即加载——这意味着 Tinder 将所有用户图片公开上传到互联网，任何人都可以看到。
• 通过 API (应用程序接口) 可访问的原始照片分辨率极高。如果你向 Tinder 上传照片，他们会对应用内使用进行缩放，但他们会将原始版本公开存储在服务器上，任何人都可以访问。
• 即使你选择“在个人资料中显示性别”，其他人仍可以通过 API (应用程序接口) 看到你的性别 ("gender": 1，其中 1=女性，0=男性)
• 如果你连续向 Tinder API (应用程序接口) 发送多个请求，你总是会得到不同的结果（例如不同的个人资料）。因此，我们可以简单地重复调用此端点来“采集”一批图片，稍后用于训练我们的神经网络。

通过分析请求头信息，我们很快找到了私有的 API 密钥：X-Auth-Token。

复制此令牌并转到 Postman，我们可以验证仅凭正确的 URL 和认证令牌，我们确实可以自由地与 Tinder API (应用程序接口) 通信。

通过点击 Tinder Web 应用的一些部分，我很快发现了所有相关的 API 端点：

类型	URL	描述
GET	/v2/recs/core	返回附近人员列表
GET	/v2/profile?include=account%2Cuser	返回关于您自己个人资料的所有信息
GET	/v2/matches	返回与您匹配的所有人员列表
GET	/like/{user_id}	喜欢给定 user_id 的人员
GET	/pass/{user_id}	跳过给定 user_id 的人员

第二步：在 Python 中构建 API（应用程序编程接口）封装

让我们开始进入代码部分。我们将使用 Python Requests 库与 API（应用程序编程接口）进行通信，并围绕它编写一个 API 封装类以便于使用。

同样，我们编写了一个小型的 Person 类，它接收来自 Tinder 的 API 响应以表示一个人员（Person），并为 tinder API 提供了一些基本接口。

让我们从 Person 类开始。它将接收 API 数据、一个 tinder-api 对象，并将所有相关数据保存到实例变量中。它还将提供一些基本功能，如“喜欢”或“不喜欢”，这些功能会向 tinder-api 发起请求，这使我们能够方便地使用 "some_person.like()" 来对我们感兴趣的个人资料点赞。

import datetime
from geopy.geocoders import Nominatim

TINDER_URL = "https://api.gotinder.com"
geolocator = Nominatim(user_agent="auto-tinder")
PROF_FILE = "./images/unclassified/profiles.txt"

class Person(object):

    def __init__(self, data, api):
        self._api = api

        self.id = data["_id"]
        self.name = data.get("name", "Unknown")

        self.bio = data.get("bio", "")
        self.distance = data.get("distance_mi", 0) / 1.60934

        self.birth_date = datetime.datetime.strptime(data["birth_date"], '%Y-%m-%dT%H:%M:%S.%fZ') if data.get(
            "birth_date", False) else None
        self.gender = ["Male", "Female", "Unknown"][data.get("gender", 2)]

        self.images = list(map(lambda photo: photo["url"], data.get("photos", [])))

        self.jobs = list(
            map(lambda job: {"title": job.get("title", {}).get("name"), "company": job.get("company", {}).get("name")}, data.get("jobs", [])))
        self.schools = list(map(lambda school: school["name"], data.get("schools", [])))

        if data.get("pos", False):
            self.location = geolocator.reverse(f'{data["pos"]["lat"]}, {data["pos"]["lon"]}')


    def __repr__(self):
        return f"{self.id}  -  {self.name} ({self.birth_date.strftime('%d.%m.%Y')})"


    def like(self):
        return self._api.like(self.id)

    def dislike(self):
        return self._api.dislike(self.id)

我们的 API 封装类不过是使用类 (Class) 来调用 tinder API 的一种更优雅的方式：

import requests

TINDER_URL = "https://api.gotinder.com"

class tinderAPI():

    def __init__(self, token):
        self._token = token

    def profile(self):
        data = requests.get(TINDER_URL + "/v2/profile?include=account%2Cuser", headers={"X-Auth-Token": self._token}).json()
        return Profile(data["data"], self)

    def matches(self, limit=10):
        data = requests.get(TINDER_URL + f"/v2/matches?count={limit}", headers={"X-Auth-Token": self._token}).json()
        return list(map(lambda match: Person(match["person"], self), data["data"]["matches"]))

    def like(self, user_id):
        data = requests.get(TINDER_URL + f"/like/{user_id}", headers={"X-Auth-Token": self._token}).json()
        return {
            "is_match": data["match"],
            "liked_remaining": data["likes_remaining"]
        }

    def dislike(self, user_id):
        requests.get(TINDER_URL + f"/pass/{user_id}", headers={"X-Auth-Token": self._token}).json()
        return True

    def nearby_persons(self):
        data = requests.get(TINDER_URL + "/v2/recs/core", headers={"X-Auth-Token": self._token}).json()
        return list(map(lambda user: Person(user["user"], self), data["data"]["results"]))

我们现在可以使用 API 查找附近的人并查看他们的个人资料，甚至可以给他们全部点赞。将 YOUR-API-TOKEN 替换为你之前在 chrome 开发者控制台中找到的 X-Auth-Token（令牌）。

if __name__ == "__main__":
    token = "YOUR-API-TOKEN"
    api = tinderAPI(token)

    while True:
        persons = api.nearby_persons()
        for person in persons:
            print(person)
            # person.like()

第三步：下载附近人员的图片

接下来，我们希望自动下载一些附近人员的图片，我们可以用它们来训练我们的 AI（人工智能）。这里的“一些”，我指的是大约 1500-2500 张图片。

首先，让我们在 Person 类中添加一个允许我们下载图片的函数。

# At the top of auto_tinder.py
PROF_FILE = "./images/unclassified/profiles.txt"

# inside the Person-class
    def download_images(self, folder=".", sleep_max_for=0):
        with open(PROF_FILE, "r") as f:
            lines = f.readlines()
            if self.id in lines:
                return
        with open(PROF_FILE, "a") as f:
            f.write(self.id+"\r\n")
        index = -1
        for image_url in self.images:
            index += 1
            req = requests.get(image_url, stream=True)
            if req.status_code == 200:
                with open(f"{folder}/{self.id}_{self.name}_{index}.jpeg", "wb") as f:
                    f.write(req.content)
            sleep(random()*sleep_max_for)

请注意，我在这里和那里添加了一些随机的休眠时间，因为如果我们向 tinder CDN（内容分发网络）发送过多请求并在几秒钟内下载大量图片，很可能会被封锁。

我们将所有人的个人资料 ID 写入名为 "profiles.txt" 的文件中。通过首先扫描文档以确定特定人员是否已经存在其中，我们可以跳过我们已经遇到过的人，并确保我们不会对同一个人进行分类多次（你稍后会明白为什么这是一个风险）。

我们现在只需遍历附近的人员并将他们的图片下载到 "unclassified" 文件夹中。

if __name__ == "__main__":
    token = "YOUR-API-TOKEN"
    api = tinderAPI(token)

    while True:
        persons = api.nearby_persons()
        for person in persons:
            person.download_images(folder="./images/unclassified", sleep_max_for=random()*3)
            sleep(random()*10)
        sleep(random()*10)

我们现在可以简单地启动此脚本并让其运行几个小时，以获取几百张附近人员的个人资料图片。如果你是 tinder PRO 用户，请时不时更新你的位置以获取新的人员。

步骤 4：手动分类图像

既然我们已经有了大量可供处理的图像，让我们构建一个非常简单且简陋的分类器。

它只需遍历我们 "未分类" 文件夹中的所有图像，并在 GUI（图形用户界面）窗口中打开图像。通过右键点击人物，我们可以将该人物标记为“不喜欢”，而左键点击则标记为“喜欢”。这将在文件名中体现：如果我们标记图像为“喜欢”，4tz3kjldfj3482.jpg 将被重命名为 1_4tz3kjldfj3482.jpg，否则为 0_4tz3kjldfj3482.jpg。标签“喜欢/不喜欢”在文件名的开头被编码为 1/0。

让我们使用 tkinter（Python 标准 GUI 库）快速编写这个 GUI：

from os import listdir, rename
from os.path import isfile, join
import tkinter as tk
from PIL import ImageTk, Image

IMAGE_FOLDER = "./images/unclassified"

images = [f for f in listdir(IMAGE_FOLDER) if isfile(join(IMAGE_FOLDER, f))]
unclassified_images = filter(lambda image: not (image.startswith("0_") or image.startswith("1_")), images)
current = None

def next_img():
    global current, unclassified_images
    try:
        current = next(unclassified_images)
    except StopIteration:
        root.quit()
    print(current)
    pil_img = Image.open(IMAGE_FOLDER+"/"+current)
    width, height = pil_img.size
    max_height = 1000
    if height > max_height:
        resize_factor = max_height / height
        pil_img = pil_img.resize((int(width*resize_factor), int(height*resize_factor)), resample=Image.LANCZOS)
    img_tk = ImageTk.PhotoImage(pil_img)
    img_label.img = img_tk
    img_label.config(image=img_label.img)

def positive(arg):
    global current
    rename(IMAGE_FOLDER+"/"+current, IMAGE_FOLDER+"/1_"+current)
    next_img()

def negative(arg):
    global current
    rename(IMAGE_FOLDER + "/" + current, IMAGE_FOLDER + "/0_" + current)
    next_img()


if __name__ == "__main__":

    root = tk.Tk()

    img_label = tk.Label(root)
    img_label.pack()
    img_label.bind("<Button-1>", positive)
    img_label.bind("<Button-3>", negative)

    btn = tk.Button(root, text='Next image', command=next_img)

    next_img() # load first image

    root.mainloop()

我们将所有未分类的图像加载到 "unclassified_images" 列表中，打开一个 tkinter 窗口，调用 next_img() 将第一张图像放入其中，并调整图像大小以适应屏幕。然后，我们注册两个点击事件，左键和右键鼠标按钮，并调用 positive/negative 函数，根据标签重命名图像并显示下一张图像。

虽然简陋但有效。

步骤 5：开发预处理器以仅裁剪出图像中的人物

对于下一步，我们需要将图像数据转换为允许我们进行分类的格式。鉴于我们的数据集，有一些困难需要考虑。

1. 数据集大小： 我们的数据集相对较小。我们有大约 2000 张图像，考虑到它们的复杂性（高分辨率 RGB（红、绿、蓝颜色模式）图像），这被认为是非常少的数据量。
2. 数据差异： 图片有时包含背面的人，有时只有脸，有时根本没有。
3. 数据噪声： 大多数图片不仅包含人物本身，还经常包含周围环境，这可能干扰我们的 AI（人工智能）。

我们通过以下方式应对这些挑战：

1. 将图像转换为灰度图 (greyscale)，以减少我们的 AI 需要学习的信息量（从 RGB 到 G，减少因子为 3）。
2. 仅裁剪出图像中包含人物的部分，其他什么都不保留。

第一部分就像使用 Pillow（Python 图像处理库）打开图像并将其转换为灰度图一样简单。第二部分，我们使用 Tensorflow Object Detection API（TensorFlow 目标检测 API），采用 mobilenet（一种轻量级神经网络架构）网络架构，该架构在 coco 数据集（COCO 通用物体识别数据集）上进行了预训练，其中也包含“人物”标签。

我们的人脸检测脚本分为四个部分：

第一部分：将预训练的 mobilenet coco 数据集作为 Tensorflow 图打开

你可以在我的 Github 仓库中找到 tensorflow mobilenet coco 图的 .pb 文件。让我们将其作为 Tensorflow 图打开：

import tensorflow as tf

def open_graph():
    detection_graph = tf.Graph()
    with detection_graph.as_default():
        od_graph_def = tf.GraphDef()
        with tf.gfile.GFile('ssd_mobilenet_v1_coco_2017_11_17/frozen_inference_graph.pb', 'rb') as fid:
            serialized_graph = fid.read()
            od_graph_def.ParseFromString(serialized_graph)
            tf.import_graph_def(od_graph_def, name='')
    return detection_graph

第二部分：将图像加载为 numpy 数组

我们使用 Pillow 进行图像处理。由于 tensorflow（深度学习框架）需要原始 numpy（Python 数值计算库）数组来处理数据，让我们编写一个小函数将 Pillow 图像转换为 numpy 数组：

import numpy as np

def load_image_into_numpy_array(image):
    (im_width, im_height) = image.size
    return np.array(image.getdata()).reshape(
        (im_height, im_width, 3)).astype(np.uint8)

第 3 部分：调用目标检测 API（应用程序接口）

下一个函数接收一张图像和一个 TensorFlow 计算图（graph），使用它运行一个 TensorFlow 会话（session），并返回所有关于检测到的类别（对象类型）、边界框（bounding boxes）和得分（scores）的信息（即物体被正确检测的置信度）。

import numpy as np
from object_detection.utils import ops as utils_ops
import tensorflow as tf

def run_inference_for_single_image(image, sess):
    ops = tf.get_default_graph().get_operations()
    all_tensor_names = {output.name for op in ops for output in op.outputs}
    tensor_dict = {}
    for key in [
        'num_detections', 'detection_boxes', 'detection_scores',
        'detection_classes', 'detection_masks'
    ]:
        tensor_name = key + ':0'
        if tensor_name in all_tensor_names:
            tensor_dict[key] = tf.get_default_graph().get_tensor_by_name(
                tensor_name)
    if 'detection_masks' in tensor_dict:
        # The following processing is only for single image
        detection_boxes = tf.squeeze(tensor_dict['detection_boxes'], [0])
        detection_masks = tf.squeeze(tensor_dict['detection_masks'], [0])
        # Reframe is required to translate mask from box coordinates to image coordinates and fit the image size.
        real_num_detection = tf.cast(tensor_dict['num_detections'][0], tf.int32)
        detection_boxes = tf.slice(detection_boxes, [0, 0], [real_num_detection, -1])
        detection_masks = tf.slice(detection_masks, [0, 0, 0], [real_num_detection, -1, -1])
        detection_masks_reframed = utils_ops.reframe_box_masks_to_image_masks(
            detection_masks, detection_boxes, image.shape[1], image.shape[2])
        detection_masks_reframed = tf.cast(
            tf.greater(detection_masks_reframed, 0.5), tf.uint8)
        # Follow the convention by adding back the batch dimension
        tensor_dict['detection_masks'] = tf.expand_dims(
            detection_masks_reframed, 0)
    image_tensor = tf.get_default_graph().get_tensor_by_name('image_tensor:0')

    # Run inference
    output_dict = sess.run(tensor_dict,
                           feed_dict={image_tensor: image})

    # all outputs are float32 numpy arrays, so convert types as appropriate
    output_dict['num_detections'] = int(output_dict['num_detections'][0])
    output_dict['detection_classes'] = output_dict[
        'detection_classes'][0].astype(np.int64)
    output_dict['detection_boxes'] = output_dict['detection_boxes'][0]
    output_dict['detection_scores'] = output_dict['detection_scores'][0]
    if 'detection_masks' in output_dict:
        output_dict['detection_masks'] = output_dict['detection_masks'][0]
    return output_dict

第 4 部分：整合所有内容以查找人物

最后一步是编写一个函数，该函数接收图像路径，使用 Pillow（图像处理库）打开图像，调用目标检测 API（应用程序接口）接口，并根据检测到的人物的边界框对图像进行裁剪。

import numpy as np
from PIL import Image

PERSON_CLASS = 1
SCORE_THRESHOLD = 0.5

def get_person(image_path, sess):
    img = Image.open(image_path)
    image_np = load_image_into_numpy_array(img)
    image_np_expanded = np.expand_dims(image_np, axis=0)
    output_dict = run_inference_for_single_image(image_np_expanded, sess)

    persons_coordinates = []
    for i in range(len(output_dict["detection_boxes"])):
        score = output_dict["detection_scores"][i]
        classtype = output_dict["detection_classes"][i]
        if score > SCORE_THRESHOLD and classtype == PERSON_CLASS:
            persons_coordinates.append(output_dict["detection_boxes"][i])

    w, h = img.size
    for person_coordinate in persons_coordinates:
        cropped_img = img.crop((
            int(w * person_coordinate[1]),
            int(h * person_coordinate[0]),
            int(w * person_coordinate[3]),
            int(h * person_coordinate[2]),
        ))
        return cropped_img
    return None

第 5 部分：将所有图像移动到相应的分类文件夹中

作为最后一步，我们编写了一个脚本，该脚本遍历“未分类”文件夹中的所有图像，检查其文件名中是否包含编码标签，并在应用之前开发的预处理步骤后，将图像复制到相应的“已分类”文件夹中：

import os
import person_detector
import tensorflow as tf

IMAGE_FOLDER = "./images/unclassified"
POS_FOLDER = "./images/classified/positive"
NEG_FOLDER = "./images/classified/negative"


if __name__ == "__main__":
    detection_graph = person_detector.open_graph()

    images = [f for f in os.listdir(IMAGE_FOLDER) if os.path.isfile(os.path.join(IMAGE_FOLDER, f))]
    positive_images = filter(lambda image: (image.startswith("1_")), images)
    negative_images = filter(lambda image: (image.startswith("0_")), images)

    with detection_graph.as_default():
        with tf.Session() as sess:

            for pos in positive_images:
                old_filename = IMAGE_FOLDER + "/" + pos
                new_filename = POS_FOLDER + "/" + pos[:-5] + ".jpg"
                if not os.path.isfile(new_filename):
                    img = person_detector.get_person(old_filename, sess)
                    if not img:
                        continue
                    img = img.convert('L')
                    img.save(new_filename, "jpeg")

            for neg in negative_images:
                old_filename = IMAGE_FOLDER + "/" + neg
                new_filename = NEG_FOLDER + "/" + neg[:-5] + ".jpg"
                if not os.path.isfile(new_filename):
                    img = person_detector.get_person(old_filename, sess)
                    if not img:
                        continue
                    img = img.convert('L')
                    img.save(new_filename, "jpeg")

每当运行此脚本时，所有带标签的图像都会被处理并移动到“已分类”目录中的相应子文件夹中。

步骤 6：重新训练 inceptionv3 并编写 Classifier（分类器）

对于重新训练部分，我们将直接使用 TensorFlow（TensorFlow 深度学习框架）的 retrain.py 脚本配合 inceptionv3 模型。

在您的项目根目录下调用该脚本，参数如下：

python retrain.py --bottleneck_dir=tf/training_data/bottlenecks --model_dir=tf/training_data/inception --summaries_dir=tf/training_data/summaries/basic --output_graph=tf/training_output/retrained_graph.pb --output_labels=tf/training_output/retrained_labels.txt --image_dir=./images/classified --how_many_training_steps=50000 --testing_percentage=20 --learning_rate=0.001

在 GTX 1080 Ti 上，学习过程大约需要 15 分钟，对于我的标记数据集，最终准确率约为 80%，但这很大程度上取决于您输入数据的质量和标注情况。

训练过程的结果是在 "tf/training_output/retrained_graph.pb" 文件中的重新训练的 inceptionV3 模型。我们现在必须编写一个 Classifier（分类器）类，该类能高效地利用 TensorFlow 图中的新 weights（权重）来进行分类预测。

让我们编写一个 Classifier（分类器）类，它将 graph（计算图）作为 session（会话）打开，并提供一个 "classify" 方法，该方法接收图像文件，返回一个包含与我们 labels（标签）"positive"（正例）和 "negative"（负例）匹配的置信度值的 dict（字典）。

该类接收图的 path（路径）以及标签文件的 path（路径）作为输入，两者都位于我们的 "tf/training_output/" 文件夹中。我们开发了辅助函数，用于将图像文件转换为可以馈送到我们 graph（计算图）中的 tensor（张量），一个用于加载 graph（计算图）和 labels（标签）的辅助函数，以及一个在我们使用完毕后关闭 graph（计算图）的重要小函数。

import numpy as np
import tensorflow as tf

class Classifier():
    def __init__(self, graph, labels):

        self._graph = self.load_graph(graph)
        self._labels = self.load_labels(labels)

        self._input_operation = self._graph.get_operation_by_name("import/Placeholder")
        self._output_operation = self._graph.get_operation_by_name("import/final_result")

        self._session = tf.Session(graph=self._graph)

    def classify(self, file_name):
        t = self.read_tensor_from_image_file(file_name)

        # Open up a new tensorflow session and run it on the input
        results = self._session.run(self._output_operation.outputs[0], {self._input_operation.outputs[0]: t})
        results = np.squeeze(results)

        # Sort the output predictions by prediction accuracy
        top_k = results.argsort()[-5:][::-1]

        result = {}
        for i in top_k:
            result[self._labels[i]] = results[i]

        # Return sorted result tuples
        return result

    def close(self):
        self._session.close()


    @staticmethod
    def load_graph(model_file):
        graph = tf.Graph()
        graph_def = tf.GraphDef()
        with open(model_file, "rb") as f:
            graph_def.ParseFromString(f.read())
        with graph.as_default():
            tf.import_graph_def(graph_def)
        return graph

    @staticmethod
    def load_labels(label_file):
        label = []
        proto_as_ascii_lines = tf.gfile.GFile(label_file).readlines()
        for l in proto_as_ascii_lines:
            label.append(l.rstrip())
        return label

    @staticmethod
    def read_tensor_from_image_file(file_name,
                                    input_height=299,
                                    input_width=299,
                                    input_mean=0,
                                    input_std=255):
        input_name = "file_reader"
        file_reader = tf.read_file(file_name, input_name)
        image_reader = tf.image.decode_jpeg(
            file_reader, channels=3, name="jpeg_reader")
        float_caster = tf.cast(image_reader, tf.float32)
        dims_expander = tf.expand_dims(float_caster, 0)
        resized = tf.image.resize_bilinear(dims_expander, [input_height, input_width])
        normalized = tf.divide(tf.subtract(resized, [input_mean]), [input_std])
        sess = tf.Session()
        result = sess.run(normalized)
        return result

步骤 7：利用这些内容实际自动玩 Tinder

既然我们已经有了 Classifier（分类器），让我们扩展之前提到的 "Person"（人物）类，并为其添加一个 "predict_likeliness"（预测喜好可能性）函数，该函数使用 Classifier（分类器）实例来验证是否应该喜欢给定的人。

# 在 Person 类中

```python
    def predict_likeliness(self, classifier, sess):
        ratings = []
        for image in self.images:
            req = requests.get(image, stream=True)
            tmp_filename = f"./images/tmp/run.jpg"
            if req.status_code == 200:
                with open(tmp_filename, "wb") as f:
                    f.write(req.content)
            img = person_detector.get_person(tmp_filename, sess)
            if img:
                img = img.convert('L')
                img.save(tmp_filename, "jpeg")
                certainty = classifier.classify(tmp_filename)
                pos = certainty["positive"]
                ratings.append(pos)
        ratings.sort(reverse=True)
        ratings = ratings[:5]
        if len(ratings) == 0:
            return 0.001
        return ratings[0]*0.6 + sum(ratings[1:])/len(ratings[1:])*0.4

现在我们需要将所有拼图碎片组合在一起。

首先，让我们使用我们的 API 令牌初始化 Tinder API（应用程序编程接口）。然后，我们使用重新训练的图和标签，将分类 TensorFlow（一种开源机器学习框架）图打开为 TensorFlow 会话。接着，我们获取附近的人并进行 Likelihood（可能性）预测。

作为额外奖励，如果 Tinder 上的人在和我相同的大学就读，我添加了一个 1.2 的 Likelihood（可能性）乘数，这样我更有可能与本地学生匹配。

对于所有预测 Likelihood（可能性）分数为 0.8 的人，我执行“喜欢”操作，对于其他人则执行“不喜欢”操作。

我开发了这个脚本，使其在启动后自动运行接下来的 2 小时。

from likeliness_classifier import Classifier
import person_detector
import tensorflow as tf
from time import time

if __name__ == "__main__":
    token = "YOUR-API-TOKEN"
    api = tinderAPI(token)

    detection_graph = person_detector.open_graph()
    with detection_graph.as_default():
        with tf.Session() as sess:

            classifier = Classifier(graph="./tf/training_output/retrained_graph.pb",
                                    labels="./tf/training_output/retrained_labels.txt")

            end_time = time() + 60*60*2
            while time() < end_time:
                try:
                    persons = api.nearby_persons()
                    pos_schools = ["Universität Zürich", "University of Zurich", "UZH"]

                    for person in persons:
                        score = person.predict_likeliness(classifier, sess)

                        for school in pos_schools:
                            if school in person.schools:
                                print()
                                score *= 1.2

                        print("-------------------------")
                        print("ID: ", person.id)
                        print("Name: ", person.name)
                        print("Schools: ", person.schools)
                        print("Images: ", person.images)
                        print(score)

                        if score > 0.8:
                            res = person.like()
                            print("LIKE")
                        else:
                            res = person.dislike()
                            print("DISLIKE")
                except Exception:
                    pass

    classifier.close()

就是这样！我们现在可以让脚本运行任意长时间，并且在不滥用拇指的情况下玩 Tinder！

如果您有问题或发现了错误，欢迎贡献到我的 Github 仓库。

许可证

MIT 许可证

Copyright (c) 2018 Joel Barmettler

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

顺便提一下，我是来自苏黎世的 AI（人工智能）工程师，从事 AI 研究，并在瑞士苏黎世担任 AI 主题演讲嘉宾 和举办 AI 网络研讨会！

Auto-Tinder 快速上手指南

⚠️ 重要免责声明 Auto-Tinder 是一个纯概念项目，仅供娱乐和教育目的。该脚本违反 Tinder 的服务条款（Terms of Service），可能导致账号被封禁。请勿在真实 Tinder 账号上使用此工具，切勿滥用以伤害他人或骚扰平台。

1. 环境准备

本项目基于 Python 3 开发，依赖 TensorFlow 进行图像识别。

• 操作系统: Windows / macOS / Linux
• 编程语言: Python 3.x
• 网络要求: 需能访问 Tinder 后端 API (api.gotinder.com) 及 Google Images CDN。
• 前置依赖:
  • requests: 用于 HTTP 请求
  • geopy: 用于地理位置解析
  • tensorflow: 用于深度学习模型推理
  • opencv-python (建议): 用于图像处理（参考文档提及 Object Detection）

2. 安装步骤

2.1 克隆项目

建议使用国内镜像加速下载：

git clone https://github.com/joelbarmettlerUZH/auto-tinder.git
cd auto-tinder

2.2 安装依赖

根据项目代码中的导入语句，安装必要的 Python 库：

pip install requests geopy tensorflow opencv-python

2.3 获取认证令牌 (Auth Token)

这是运行脚本的关键步骤。你需要从浏览器开发者工具中获取你的 X-Auth-Token。

1. 打开 tinder.com 并登录。
2. 按 F12 打开开发者工具，切换到 Network 标签页。
3. 刷新页面，查找请求头中包含 X-Auth-Token 的请求。
4. 复制该 Token 值，后续将在代码中配置使用。

3. 基本使用

项目核心逻辑包含一个 API 包装类和一个用户对象类。以下是基于 README 提供的核心代码结构示例。

3.1 初始化 API 接口

使用 tinderAPI 类封装与 Tinder 后端的交互：

import requests

TINDER_URL = "https://api.gotinder.com"

class tinderAPI():

    def __init__(self, token):
        self._token = token

    def profile(self):
        data = requests.get(TINDER_URL + "/v2/profile?include=account%2Cuser", headers={"X-Auth-Token": self._token}).json()
        return Profile(data["data"], self)

    def matches(self, limit=10):
        data = requests.get(TINDER_URL + f"/v2/matches?count={limit}", headers={"X-Auth-Token": self._token}).json()
        return list(map(lambda match: Person(match["person"], self), data["data"]["matches"]))

    def like(self, user_id):
        data = requests.get(TINDER_URL + f"/like/{user_id}", headers={"X-Auth-Token": self._token}).json()
        return {
            "is_match": data["match"],
            "liked_remaining": data["likes_remaining"]
        }

    def dislike(self, user_id):
        requests.get(TINDER_URL + f"/pass/{user_id}", headers={"X-Auth-Token": self._token}).json()
        return True

    def nearby_

3.2 处理用户数据

Person 类用于解析 API 返回的 JSON 数据，并提供简单的点赞/跳过接口：

import datetime
from geopy.geocoders import Nominatim

TINDER_URL = "https://api.gotinder.com"
geolocator = Nominatim(user_agent="auto-tinder")
PROF_FILE = "./images/unclassified/profiles.txt"

class Person(object):

    def __init__(self, data, api):
        self._api = api

        self.id = data["_id"]
        self.name = data.get("name", "Unknown")

        self.bio = data.get("bio", "")
        self.distance = data.get("distance_mi", 0) / 1.60934

        self.birth_date = datetime.datetime.strptime(data["birth_date"], '%Y-%m-%dT%H:%M:%S.%fZ') if data.get(
            "birth_date", False) else None
        self.gender = ["Male", "Female", "Unknown"][data.get("gender", 2)]

        self.images = list(map(lambda photo: photo["url"], data.get("photos", [])))

        self.jobs = list(
            map(lambda job: {"title": job.get("title", {}).get("name"), "company": job.get("company", {}).get("name")}, data.get("jobs", [])))
        self.schools = list(map(lambda school: school["name"], data.get("schools", [])))

        if data.get("pos", False):
            self.location = geolocator.reverse(f'{data["pos"]["lat"]}, {data["pos"]["lon"]}')


    def __repr__(self):
        return f"{self.id}  -  {self.name} ({self.birth_date.strftime('%d.%m.%Y')})"


    def like(self):
        return self._api.like(self.id)

    def dislike(self):
        return self._api.dislike(self.id)

3.3 运行流程

1. 获取推荐列表: 调用 tinderAPI 获取附近的用户数据。
2. 图像预处理: 使用 TensorFlow Object Detection API 裁剪出人物主体。
3. 模型推理: 加载训练好的 InceptionV3 模型对图片进行分类（喜欢/不喜欢）。
4. 执行操作: 根据分类结果调用 Person.like() 或 Person.dislike()。

注意: 由于原始 README 内容截断，完整的项目实现需要开发者自行补充剩余的训练数据和主循环逻辑。