Ranking and Compare System

[JIHONGKING]

how to build a system that uses the Upstage API to compare job candidates' skills and rank them.

1. Data Preparation

First, define the skill lists for each candidate and assign importance weights to each skill. Also, include the percentile rankings of the candidates.

A_skills = ["Python", "Data Analysis", "Machine Learning"]
B_skills = ["Java", "Web Development", "Database Management"]
skill_weights = {"Python": 0.8, "Data Analysis": 0.7, "Machine Learning": 0.9,
                 "Java": 0.7, "Web Development": 0.6, "Database Management": 0.8}
A_percentile = 50
B_percentile = 60

2. Embedding Generation

Use the Upstage API to generate embedding vectors for each skill.

import requests

def get_embeddings(skills):
    url = "https://api.upstage.ai/v1/embedding"
    headers = {"Authorization": "Bearer YOUR_API_KEY"}
    embeddings = []

    for skill in skills:
        payload = {"text": skill}
        response = requests.post(url, headers=headers, json=payload)
        embeddings.append(response.json()["embedding"])

    return embeddings

A_embeddings = get_embeddings(A_skills)
B_embeddings = get_embeddings(B_skills)

3. Creating Profile Vectors

Combine the skill embeddings for each candidate by applying the importance weights.

import numpy as np

def create_profile_vector(embeddings, skills, skill_weights):
    weighted_embeddings = [np.array(emb) * skill_weights[skill] for emb, skill in zip(embeddings, skills)]
    return np.sum(weighted_embeddings, axis=0)

A_profile = create_profile_vector(A_embeddings, A_skills, skill_weights)
B_profile = create_profile_vector(B_embeddings, B_skills, skill_weights)

4. Similarity Calculation

Calculate the cosine similarity between the profile vectors of the two candidates.

from sklearn.metrics.pairwise import cosine_similarity

similarity = cosine_similarity([A_profile], [B_profile])[0][0]

5. Ranking and Comparison

Use the Upstage API to compare the two candidates and generate suggestions for B to catch up with A.

def compare_candidates(A_skills, A_percentile, B_skills, B_percentile, similarity):
    url = "https://api.upstage.ai/v1/compare"
    headers = {"Authorization": "Bearer YOUR_API_KEY"}
    prompt = f"""
    We have two job candidates, A and B.
    A's skills: {A_skills}, top {A_percentile}%
    B's skills: {B_skills}, top {B_percentile}%
    Skill similarity between the two candidates: {similarity}

    1. Compare these two candidates based on this information.
    2. Suggest what B can do to catch up with A.
    """
    payload = {"prompt": prompt}
    response = requests.post(url, headers=headers, json=payload)
    return response.json()["response"]

comparison_result = compare_candidates(A_skills, A_percentile, B_skills, B_percentile, similarity)
print(comparison_result)

6. Function for Ranking

Define custom functions for similarity calculation and ranking determination.

def calculate_rank(percentile, similarity):
    # Example ranking calculation logic
    return percentile * (1 - similarity)

A_rank = calculate_rank(A_percentile, similarity)
B_rank = calculate_rank(B_percentile, similarity)

7. Groundedness Check

Verify that the model's output matches the input data.

def groundedness_check(response, data):
    # Verify that the model's output aligns with the input data
    pass

groundedness_check(comparison_result, [A_skills, B_skills, A_percentile, B_percentile, similarity])

This code sample demonstrates how to use the Upstage API to compare job candidates' skills, rank them, and generate improvement suggestions. Ensure you use a valid API key and incorporate additional logic as needed for a complete implementation.

[JIHONGKING]

What is Embedding ?

What is an Embedding?

An embedding is a way to convert high-dimensional data, like text, into low-dimensional vectors. These vectors represent the meaning of the original text in a numerical form. Embeddings are widely used in Natural Language Processing (NLP) to help machine learning models understand and process text data.

Why Use Embeddings?

1. Dimensionality Reduction: Converting text data into vectors makes it easier for machine learning models to handle.
2. Meaningful Representation: Similar words have similar vectors, allowing us to compare their meanings.
3. Efficiency: Vectors are computationally efficient to work with and require less memory.

How Are Embeddings Created?

There are several methods to create embeddings. Here’s a simple example:

1. Word Embedding Example: Suppose we have the words "cat," "dog," and "apple." We can represent these words as 3-dimensional vectors:

   • "cat" -> [0.5, 0.1, 0.9]
   • "dog" -> [0.4, 0.2, 0.8]
   • "apple" -> [0.9, 0.7, 0.1]

   In this case, "cat" and "dog" are similar animals, so their vectors are similar. "Apple" is a different concept, so its vector is different.

2. Sentence Embedding Example: For a sentence like "I love programming," the embedding might look like this:

   • "I love programming" -> [0.2, 0.9, 0.6, 0.3, 0.7]

Using Embeddings

Embeddings can be used in various ways. For example, we can measure the similarity between two vectors using cosine similarity. Cosine similarity calculates the angle between two vectors to determine how similar they are.

Conclusion

Embeddings are a crucial technique for transforming text data into a numerical format that machine learning models can understand. They help retain the meaning of the data while making it more manageable and efficient to process.

[JIHONGKING]

flowchart TD A[Data Preparation] B[Embedding Generation] C[Profile Vector Creation] D[Similarity Calculation] E[Ranking and Comparison] F[Function Calling] G[Groundedness Check]

A --> B
B --> C
C --> D
D --> E
E --> F
F --> G

subgraph Data_Preparation
    A1[Input: Candidate skills]
    A2[Input: Skill weights]
    A3[Input: Candidate percentile rankings]
    A4[Output: Prepared data for embedding generation]
    A1 --> A4
    A2 --> A4
    A3 --> A4
end

subgraph Embedding_Generation
    B1[Input: Candidate skills]
    B2[Process: Generate skill embeddings using Upstage API]
    B3[Output: Skill embeddings]
    B1 --> B2
    B2 --> B3
end

subgraph Profile_Vector_Creation
    C1[Input: Skill embeddings]
    C2[Input: Skill weights]
    C3[Process: Combine skill embeddings with weights]
    C4[Output: Profile vectors]
    C1 --> C3
    C2 --> C3
    C3 --> C4
end

subgraph Similarity_Calculation
    D1[Input: Profile vectors]
    D2[Process: Calculate cosine similarity]
    D3[Output: Similarity score]
    D1 --> D2
    D2 --> D3
end

subgraph Ranking_and_Comparison
    E1[Input: Candidate skills]
    E2[Input: Percentile rankings]
    E3[Input: Similarity score]
    E4[Process: Compare candidates using Upstage API]
    E5[Output: Comparison result and suggestions]
    E1 --> E4
    E2 --> E4
    E3 --> E4
    E4 --> E5
end

subgraph Function_Calling
    F1[Input: Similarity score]
    F2[Input: Percentile rankings]
    F3[Process: Define custom ranking functions]
    F4[Output: Calculated ranks]
    F1 --> F3
    F2 --> F3
    F3 --> F4
end

subgraph Groundedness_Check
    G1[Input: Comparison result]
    G2[Input: Original data]
    G3[Process: Verify alignment with input data]
    G4[Output: Verified results]
    G1 --> G3
    G2 --> G3
    G3 --> G4
end

[JIHONGKING]

Backend Code

The following code is a backend implementation using Flask to handle user data, generate embedding vectors, compute similarities, and prepare data for visualization.

from flask import Flask, request, jsonify
import requests
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity
import matplotlib.pyplot as plt

app = Flask(__name__)

# Predefined skill weights
skill_weights = {"Python": 0.8, "Data Analysis": 0.7, "Machine Learning": 0.9,
                 "Java": 0.7, "Web Development": 0.6, "Database Management": 0.8, 
                 "Deep Learning": 0.85, "Frontend Development": 0.8, "Project Management": 0.7, 
                 "Figma": 0.5, "Adobe Photoshop": 0.5, "React": 0.8, "Education": 0.5, 
                 "IT": 0.7}

# Function to generate skill embeddings
def get_embeddings(skills):
    url = "https://api.upstage.ai/v1/embedding"
    headers = {"Authorization": "Bearer YOUR_API_KEY"}
    embeddings = []
    for skill in skills:
        payload = {"text": skill}
        response = requests.post(url, headers=headers, json=payload)
        embeddings.append(response.json()["embedding"])
    return embeddings

# Function to create profile vector
def create_profile_vector(embeddings, skills, skill_weights):
    weighted_embeddings = [np.array(emb) * skill_weights.get(skill, 0.5) for emb, skill in zip(embeddings, skills)]
    return np.sum(weighted_embeddings, axis=0)

# Endpoint to process single user data
@app.route('/processData', methods=['POST'])
def process_data():
    data = request.json
    key_strengths = data['keyStrengths']
    skills = data['skills']
    field = data['field']

    combined_skills = key_strengths + skills + field
    embeddings = get_embeddings(combined_skills)
    profile_vector = create_profile_vector(embeddings, combined_skills, skill_weights)

    return jsonify({"profile_vector": profile_vector.tolist()})

# Endpoint to compare multiple users
@app.route('/compareUsers', methods=['POST'])
def compare_users():
    users = request.json["users"]

    user_profiles = []
    for user in users:
        combined_skills = user["keyStrengths"] + user["skills"] + user["field"]
        embeddings = get_embeddings(combined_skills)
        profile_vector = create_profile_vector(embeddings, combined_skills, skill_weights)
        user_profiles.append({
            "name": user["name"], 
            "profile": profile_vector, 
            "percentile": user["percentile"], 
            "experience_duration": user["experience_duration"],  # Experience duration
            "experience_weight": user["experience_weight"]  # Experience weight
        })

    similarities = []
    for i in range(len(user_profiles)):
        for j in range(i + 1, len(user_profiles)):
            sim = cosine_similarity([user_profiles[i]["profile"]], [user_profiles[j]["profile"]])[0][0]
            similarities.append({
                "user1": user_profiles[i]["name"], 
                "user2": user_profiles[j]["name"], 
                "similarity": sim
            })
            print(f"Similarity between {user_profiles[i]['name']} and {user_profiles[j]['name']}: {sim}")

    # Return user profile vectors and similarity data
    return jsonify({
        "user_profiles": [{
            "name": user["name"], 
            "profile": user["profile"].tolist(), 
            "percentile": user["percentile"], 
            "experience_duration": user["experience_duration"],
            "experience_weight": user["experience_weight"]
        } for user in user_profiles],
        "similarities": similarities
    })

if __name__ == '__main__':
    app.run(debug=True)

Explanation

1. Function to generate skill embeddings: The get_embeddings function uses the Upstage API to generate embedding vectors for the given skills.
2. Function to create profile vector: The create_profile_vector function applies weights to the skill embeddings and sums them to create a profile vector.
3. Endpoint to process single user data: The /processData endpoint processes data for a single user, generating their profile vector.
4. Endpoint to compare multiple users: The /compareUsers endpoint processes data for multiple users, generating embedding vectors, calculating similarities, and returning necessary data for visualization. This includes experience duration and experience weight for each user.

This code is structured to allow for future additions, such as visualization, by returning all the necessary data (profile vectors, similarities, experience duration, and experience weight). This approach helps backend developers compare and analyze user data effectively.