春招 | BOSS直聘推荐算法一面

来源：投稿  作者：LSC
编辑：学姐

1.自我介绍

2.推荐的召回和排序

3.找第k大的树

int partition(int a[], int left, int right)
{
 int tmp = a[left];
 while (left  {
  while (left   a[left] = a[right];
  while (left = tmp) { left++; }
  a[right] = a[left];
 }
 a[left] = tmp;
 return left;
}

int findk(int a[], int left, int right, int k)
{
 int pos = partition(a, left, right);
 if (pos == k) { return a[pos]; }
 if (pos > k) { return findk(a, left, pos - 1, k); }
 return findk(a, pos + 1, right, k);
}

4.大语言模型的损失函数

大语言模型的损失函数通常是基于最大似然估计来训练的。具体来说，这个损失函数可以被定义为交叉熵损失，用于衡量模型生成的文本与真实文本之间的差异。

5.数组排序的方法

6.逻辑回归的损失函数

7.写一个逻辑回归

import numpy as np

class LR:
    def __init__(self, w=None, b=None, dim=5, lr=1e-3, num_epoch=10):
        if w != None:
            self.w = w
        else:
            self.w = np.ones((dim, 1))
        if b != None:
            self.b = b
        else:
            self.b = 0.001
        self.lr = lr
        self.num_epoch = num_epoch
    def sigmoid(self, x):
        return 1 / (1 + np.exp(-x))

    def func(self, cost, x, w, b, y, code='w'):
        z = -np.dot(self.w, x) + self.b
        t = np.exp(z) + 1
        res = 0
        if code == 'w':
            res = 2 * self.x * np.pow(t, -3) - 2 * x * y * np.pow(t, -2)
        else:
            res = -2 * np.pow(t, -3) + 2 * y * np.pow(t, -2)
        return res

    def train(self, x, y):
        for epoch in range(self.num_epoch):
            z = np.dot(self.w, x) + self.b
            t = self.sigmoid(z)
            cost = - (y * np.log(t) + (1 - y) * np.log(1 - t))

            dw = self.func(cost, x, self.w, self.b, y, 'w')
            db = self.func(cost, x, self.w, self.b, y, 'b')

            self.w -= self.lr * dw
            self.b -= self.lr * db

    def predict(self, x):
        t = np.dot(self.w, x) + self.b
        tmp = self.sigmoid(t)
        y = []
        for i in tmp:
            if i >= 0.5:
                y.append(1)
            else:
                y.append(0)
        return np.array(y)

8.大语言模型在推荐的应用