Il y a beaucoup de réseaux neuronaux dernièrement, comment les utilises-tu au travail, à quelle fréquence et de quelle manière précisément?
Machine Learning / AI
Comment comparer une affiche affichée sur la page de l'utilisateur avec celles qu'il n'a pas vues (retour d'information partiel) ?
Quelle est la dispersion précisément dans l'estimation IPS ?
Proposez brièvement comment reconditionner l'expérience RAG pour les systèmes de recommandation, puis des questions types. Pas comment répondre, mais en quoi cela consiste selon mon expérience et mon CV.
Comment fonctionne la perte de contraste avec des négatifs en batch ?
Comment se fait la mise à jour incrémentielle de l'index FAISS en production?
Qu'est-ce que les items ? Comment cela se prononce-t-il correctement ?
Écrivez un court paragraphe de présentation où vous mettez en évidence que les systèmes de recommandation ressemblent beaucoup à RAG - récupération, re-ranking, similitudes architecturales, etc., afin que je puisse m'en souvenir et le raconter.
Évaluez combien de données sont nécessaires pour le fine-tuning du modèle en production, décrivez le processus de fine-tuning, les paramètres, la fonction de perte (contrastive/triplet) et pourquoi celle-ci a été choisie.
# Formulez et écrivez la définition de ce qu'est roc auc. # Comment calcule-t-on le score roc auc? # Écrivez une fonction qui calcule roc_auc_score selon la définition écrite. # Et pour un nombre arbitraire de classes avec un ordre de priorité donné? # Le modèle fonctionne comme suit # y_score[i] >= seuil -> y_pred[i] = 1 # y_score[i] < seuil -> y_pred[i] = 0 def test_roc_aur_score(): y_true = [0, 0, 0, 1, 0, 0] y_score = [0.2, 0.4, 0.31, 0.6, 0.3, 0.7] res_metric = roc_auc_score(y_true, y_score) assert res_metric == 0.8 y_true = [0, 1, 0, 0, 0, 1] y_score = [0.7, 0.6, 0.31, 0.31, 0.3, 0.2] res_metric = roc_auc_score(y_true, y_score) assert res_metric == 0.375 y_true = [0, 0, 0, 1, 0, 0] y_score = [0.2, 0.4, 0.31, 0.8, 0.3, 0.7] res_metric = roc_auc_score(y_true, y_score) assert res_metric == 1 y_true = [0, 0, 0, 0, 0, 0] y_score = [0.2, 0.4, 0.31, 0.8, 0.3, 0.7] res_metric = roc_auc_score(y_true, y_score) assert res_metric == 0 # Tests bonus pour plusieurs classes y_true = [0, 1, 0, 0.5, 0, 1] y_score = [0.7, 0.6, 0.31, 0.31, 0.3, 0.2] res_metric = roc_auc_score(y_true, y_score) assert res_metric == 0. y_true = [0, 0.1, 0.2, 0.3, 0.4, 0.6] y_score = [0, 0.1, 0.2, 0.3, 0.4, 0.6] res_metric = roc_auc_score(y_true, y_score) assert res_metric == 1
Que faire si un bloc a des quantités différentes de contenu — il y a des blocs unitaires, et d'autres avec 30 éléments ? Comment travailler avec les scores du contenu pour obtenir une fonctionnalité de ce bloc ?
Ai-je bien compris : nous avons un tracker qui a une note moyenne du tracker de contenu pour le remplissage du bloc, il y a des caractéristiques utilisateur et de bloc, nous avons pris un positif — qu'est-ce exactement ?
Veuillez nous expliquer en détail de quel projet il s'agissait et quelles étaient précisément vos responsabilités.
Pourquoi le projet a-t-il été développé pendant deux ans, alors que tu dis que l'essentiel a été fait il y a deux ans ? Le projet est-il en maintenance ou a-t-il été davantage développé ?
Si on vous donnait un nombre illimité de GPU pour améliorer la qualité du système, quelle direction choisiriez-vous en premier?
Qu'est-ce que le DSSM, tu sais?
Pourquoi alors le ranker sera-t-il entraîné ? C'est-à-dire qu'il sera indépendant du contenu — quel sera son objectif ?
Quel format de travail envisagez-vous et dans quelle ville vivez-vous?
Parle-moi de ton expérience, qu'as-tu fait ces cinq dernières années?
# étant donné un tableau a = [1, 20, 10, 0, 59, 63, 0, 88, 0] -> [0, 0, 0, 1, 20, 10, 59, 63, 88] # il faut écrire une fonction optimale qui déplace les zéros au début du tableau et conserve l'ordre des autres éléments def move_zeros_to_left(a: List[int]) -> List[int]: pass