Consulte la API de Job Search con Google Cloud

En este codelab, aprenderás a mejorar la búsqueda de empleo y la adquisición de talentos para tu organización con la API de Cloud Talent Solution (CTS). Con CTS, puedes agregar la potencia del aprendizaje automático a tu experiencia de búsqueda de empleo.

Qué aprenderás

  • Habilita CTS en tu proyecto de Google Cloud
  • Cómo buscar trabajos disponibles con la API de Job Search

Requisitos

  • Ya existe un proyecto de Google Cloud con facturación (si no tienes uno, crea uno).
  • Aproximadamente una hora

¿Cómo usarás este instructivo?

Solo leerlo Leer y completar los ejercicios

¿Cómo calificarías tu experiencia anterior con Google Cloud Platform?

Principiante Intermedio Experto

Este instructivo se diseñó para ejecutarse completamente en Google Cloud Platform. No es necesario realizar descargas en tu estación de trabajo.

Habilitar la API de Cloud Talent Solutions

Abra su aplicación en Cloud Console y haga clic en el menú de opciones en la esquina superior izquierda. Explore los menús para Talent Solution -> Overview.

Como este es un proyecto nuevo, se te redireccionará a una pantalla nueva que te pedirá que habilites la API. Haz clic en Habilitar y espera unos minutos para que la API se active en este proyecto.

Habilitar el registro de datos

Ahora regrese a la página Resumen. Aparecerá un nuevo diálogo en el que se le solicitará que habilite el registro de datos. Esto solo permite asegurarse de que la API de Job Search funciona con un modelo de aprendizaje automático que necesita datos. Como parte de la integración, realmente podrás enviar eventos de usuarios que busquen entrenar aún más esos modelos. Cuando se implementa mediante código, puede especificar qué información se envía.

Profundizaremos en cuáles son esos eventos y cómo enviarlos más adelante, pero los modelos previamente entrenados funcionarán bien. Habilita el registro de datos y, luego, haz clic en Conexiones de cuenta de servicio en el panel de navegación izquierdo de este diálogo.

Configura una cuenta de servicio

Cuando realices solicitudes a la API, deberás hacerlas en nombre de una cuenta autenticada real. En las prácticas recomendadas de Google Cloud Platform, se recomienda configurar una cuenta de servicio para esto. Piense en las cuentas de servicio como una manera fácil de configurar a los usuarios autenticados que tienen permisos limitados. Esto te ayudará a crear un sistema independiente y seguro.

Por ejemplo, necesitaremos una cuenta de servicio para usar la API de Job Search. ¡Creemos una! Después de hacer clic en “Service Account Connections”, haz clic en “Manage Service Accounts” en la parte superior de la página y, luego, en “Create Service Account” (Crear cuenta de servicio). Otorga permisos de lectura y escritura con el editor de trabajos en la sección Cloud Talent Solution del menú de la izquierda. También es posible configurar una cuenta de servicio con solo un "Visualizador de trabajos", de modo que solo tenga acceso de solo lectura.

En el siguiente paso, se te preguntará si deseas permitir que los usuarios accedan a esta cuenta de servicio. Puedes omitir este paso, pero asegúrate de hacer clic en &" Crear clave" cerca de la parte inferior. Se descargará un archivo de credencial JSON nuevo de manera automática. Almacena este archivo en tu servidor, ya que el código que escribas en una sección posterior lo usará para autenticarse.

Configure las variables de entorno

Para mayor comodidad, usaremos Google Cloud Shell. Si deseas hacerlo desde tu propio entorno de desarrollo, ¡fantástico! Asegúrate de instalar el SDK de Google Cloud y las bibliotecas cliente en el lenguaje que prefieras (en este codelab, se usa Python). Cloud Shell ya tendrá instaladas las bibliotecas cliente de Cloud. Práctico, ¿no?

Para ejecutar código con las bibliotecas, debes asegurarte de que dos variables de entorno estén configuradas: una para especificar el ID del proyecto y la otra para especificar el archivo de claves de tu cuenta de servicio. Establezcamos eso.

En su proyecto, haga clic en el ícono de la parte superior derecha de su consola web para abrir Cloud Shell. Agrega las siguientes variables de entorno para especificar el ID de tu proyecto y establecer una ruta de acceso al archivo de claves JSON:

export GOOGLE_CLOUD_PROJECT="your-project-id"
export GOOGLE_APPLICATION_CREDENTIALS=/path/to/key.json"

Antes de realizar búsquedas en el sistema, debemos asegurarnos de que algunas realmente existan.

Si deseas obtener información sobre cómo agregar empresas y trabajos con la API, ¡fantástico! Continúa y realiza el codelab sobre ese tema. De lo contrario, en esta sección se te guiará.

Abra el editor de código en Cloud Shell

En Google Cloud Console, abra Cloud Shell con el ícono de Cloud Shell que se encuentra en la parte superior derecha.

En la parte superior derecha de Cloud Shell, verá una serie de íconos. Haz clic en File -> Launch Code Editor, como se muestra a continuación:

Crea algunas empresas y trabajos.

Usa File -> New File para crear un archivo de origen nuevo y completarlo con el contenido que se indica a continuación. Asígnale el nombre create_some_jobs.py.

Ten en cuenta que el uso de la API para crear empresas y trabajos está fuera del alcance de este codelab. En el codelab anterior, la API de Job Search, se explica cómo hacerlo. El siguiente código solo crea algunos trabajos en el sistema para poder experimentar con diferentes funciones de la API de búsqueda y ver los resultados que aparecen.

create_some_jobs .py

import os

from googleapiclient.discovery import build
from googleapiclient.errors import Error

# Build the service object, passing in the api name and api version
client_service = build('jobs', 'v3')


project_id = 'projects/' + os.environ['GOOGLE_CLOUD_PROJECT']


def create_company(request):
    # This is the API call that actually creates the new company.
    result = client_service.projects().companies().create(
        parent=project_id, body=request).execute()
    return result


def create_job(request):
    # The actual API call happens here.
    result = client_service.projects().jobs().create(
        parent=project_id, body=request).execute()
    print('Job created: %s' % result)
    return result


def create_foo():
    foocorp_company_request = {
        "company": {
            'display_name': "FooCorp",
            'external_id': "foo2_llc"
        }
    }

    result_company = create_company(foocorp_company_request)
    company_name = result_company.get('name')

    job = {
        'company_name': company_name,
        'title': 'Senior Software Engineer',
        'addresses': ["Mountain View, CA"],

        'description':
        """Experienced software engineer required for full-time position.
        Leadership ability and ability to thrive in highly competitive environment a must.
        <p />Ignore postings from that "Bar" company, their microkitchen is terrible.  Join Team Foo!""",
        'requisition_id': 'foo_swe',
        'application_info': {
            'uris': ['http://www.example.com/foo/software-engineer-application'],
            'emails': ['apply@example.com']
        }
    }
    request = {'job': job}
    result_job = create_job(request)


def create_horsehub():
    horsehub_company_request = {
        "company": {
            'display_name': "Horse Hub",
            'external_id': "horsies_llc"
        }
    }

    result_company = create_company(horsehub_company_request)
    company_name = result_company.get('name')

    job = {
        'company_name': company_name,
        'title': 'Junior Software Engineer',
        'description':
        """Hiring entry level software engineer required for full-time position.
        Must be passionate about industry intersection of horses and technology.
        Ability to intelligently discuss the equine singularity a major bonus.
        <p />C'mon bub! Join Horse Hub!""",
        'requisition_id': 'hh_swe',
        'application_info': {
            'uris': ['http://www.example.com/foo/software-engineer-horsehub'],
            'emails': ['apply-horsehub@example.com']
        }
    }
    request = {'job': job}
    result_job = create_job(request)


def create_tandem():
    tandem_company_request = {
        "company": {
            'display_name': "Tandem",
            'external_id': "tandem"
        }
    }

    result_company = create_company(tandem_company_request)
    company_name = result_company.get('name')

    job = {
        'company_name': company_name,
        'title': 'Test Engineer',
        'description':
        """Hiring Test Engineer for full-time position with Tandem.  Must be detail oriented
        and (obviously) comfortable with pair programming.  Will be working with team of Software Engineers.
        <p />Join Tandem today!""",
        'requisition_id': 'tandem_te',
        'application_info': {
            'uris': ['http://www.example.com/tandem/test-engineer'],
            'emails': ['apply-tandem-test@example.com']
        },
        'promotionValue': 1
    }
    request = {'job': job}
    result_job = create_job(request)
    job['requisition_id'] = 'a_tandem_te'
    result_job = create_job(request)


try:
    create_foo()
    create_horsehub()
    create_tandem()

except Error as e:
    print('Got exception while creating company')
    raise e

Ejecuta el código anterior desde la consola.

$ python create_some_jobs.py
Job created:
(Lots of output here)

Para cada búsqueda, tendremos que proporcionar dos objetos: Request y RequestMetadata.

Enfoquémonos primero en RequestMetadata.

El objeto RequestMetadata proporciona información sobre el usuario que realiza la solicitud de búsqueda. Es importante brindar estos detalles para garantizar una experiencia del usuario coherente y capacitar mejor los modelos de aprendizaje automático.

Las siguientes cuatro propiedades conforman el objeto de solicitud:

  • domain (obligatorio) es el dominio desde el que se aloja la búsqueda, como foo.com.
  • sessionId (obligatorio): Es una string de identificación única para una sesión. La sesión se define como la duración de una interacción del usuario final con el servicio durante un período determinado.
  • userId (obligatorio) es una string de identificación única que representa al usuario.
  • deviceInfo (opcional) consiste en el ID y el tipo de dispositivo, de modo que pueda distinguir entre una búsqueda web y una búsqueda en aplicaciones, por ejemplo.

La lista completa de campos, junto con la información de tipos y descripciones, también está disponible en la documentación de RequestMetadata.

Estos son los pasos mínimos para realizar una búsqueda:

  1. Define el objeto RequestMetadata
  2. Toma esa RequestMetadata y colócala en un objeto "request"
  3. Realizar una búsqueda de la API de Jobs con esa solicitud como definición de nuestra consulta
  4. Inspecciona los resultados.

Veamos cómo se ve. Abra un nuevo archivo, search_jobs.py, y pegue lo siguiente.

search_jobs.py

import os

from googleapiclient.discovery import build
from googleapiclient.errors import Error

client_service = build('jobs', 'v3')
project_id = 'projects/' + os.environ['GOOGLE_CLOUD_PROJECT']

# 1) Define RequestMetadata object
request_metadata = {
    'domain':     'example.com',
    'session_id': 'a5ed434a3f5089b489576cceab824f25',
    'user_id':    '426e428fb99b609d203c0cdb6af3ba36',
}

try:
    # 2) Throw RequestMetadata object in a request
    request = {
        'request_metadata': request_metadata,
    }

    # 3) Make the API call
    response = client_service.projects().jobs().search(
        parent=project_id, body=request).execute()

    # 4) Inspect the results
    if response.get('matchingJobs') is not None:
        print('Search Results:')
        for job in response.get('matchingJobs'):
            print('%s: %s' % (job.get('job').get('title'),
                                job.get('searchTextSnippet')))
    else:
        print('No Job Results')

except Error as e:
    # Alternate 3) or 4) Surface error if things don't work.
    print('Got exception while searching')
    raise e

Intenta ejecutar esta búsqueda.

$ python search_jobs.py
Search Results:
Junior Software Engineer: None
Senior Software Engineer: None
Test Engineer: None
Test Engineer: None

Se mostraron todos los trabajos del sistema.

¿Por qué?

Debido a que aún no especificaste ningún parámetro de búsqueda. Pero ¿cómo lo lograrías? Si solo la siguiente sección abarcara algo útil, pero completamente necesario para buscar en una base de datos. Algo así...

Agrega un objeto JobQuery con parámetros de búsqueda

Técnicamente, RequestMetadata es el único campo de solicitud obligatorio, pero lo más probable es que queremos buscar algo, así que también incluiremos una JobQuery. JobQuery puede ser un objeto bastante simple, con una string de consulta para los términos de búsqueda reales y diferentes filtros que ayudan a reducir los trabajos que se muestran. Por ejemplo, puedes mostrar solo trabajos de una empresa específica o filtrarlos por tipo de empleo. Por ahora, seguiremos con la cadena de consulta, pero encontrarás más información sobre los filtros disponibles en la documentación de JobQuery.

Modifique el código anterior para incluir una JobQuery y agréguelo a su solicitud existente.

search_jobs.py

...
# Create a job query object, which is just a key/value pair keyed on "query"
job_query = {'query': 'horses'}
...
    # Update the request to include the job_query field.
    request = {
        'request_metadata': request_metadata,
        'job_query': job_query
    }
 ...

Luego, vuelve a ejecutar la búsqueda.

$ python search_jobs.py
Search Results:
Junior Software Engineer: Hiring entry level software engineer required for full-time position. Must be
passionate about industry intersection of <b>horses</b> and technology. Ability to
intelligently discuss the equine singularity a major&nbsp;...

¡Mejor! Mejor de varias maneras. Desglosemos lo que sucedió:

  • La API de búsqueda tomó el parámetro de búsqueda y solo mostró un resultado coincidente
  • El resultado que se mostró incluyó un fragmento con formato HTML con el término de búsqueda coincidente negrita para mostrarlo con más facilidad en su lista de resultados de la búsqueda.
  • Agregar una búsqueda era solo 2 líneas de código adicionales.

A esta altura, ya comenzó a usar la búsqueda básica de trabajos. Puedes ejecutar consultas en una base de datos de trabajo y recuperar resultados. Sin embargo, hay muchísimas cosas por venir.

Cómo limitar la cantidad de datos que se muestran con jobView

También puedes especificar una propiedad jobView, que es un ENUM que declara la información que deseas obtener con tu solicitud de búsqueda. JOB_VIEW_FULL te proporciona toda la información sobre cada resultado del trabajo, pero te recomendamos guardar algunos bytes y elegir otra opción que muestre menos campos. Elige la opción más adecuada para la plataforma en la que estás trabajando. Los posibles valores (tomados de la documentación de JobView) son los siguientes:

  • JOB_VIEW_UNSPECIFIED: opción predeterminada.
  • JOB_VIEW_ID_ONLY: Contiene solo el nombre del trabajo, el ID de requerimiento y el código de idioma.
  • JOB_VIEW_MINIMAL - Todo lo que hay en la vista ID_ONLY, más el cargo, el nombre de la empresa y las ubicaciones.
  • JOB_VIEW_SMALL: Todo en la vista MINIMAL, más la visibilidad y la descripción del empleo.
  • JOB_VIEW_FULL: Todos los atributos disponibles.

Para obtener una vista más detallada de los campos disponibles, puede consultar la documentación de Job, el objeto que se muestra en los resultados de la búsqueda. A continuación, se muestra un ejemplo de cómo especificar el objeto JobView en tu objeto de solicitud.

    # What your request object looks like with a jobView field
    request = {
        'requestMetadata': request_metadata,
        'jobQuery': job_query,
        'jobView' : 'JOB_VIEW_FULL'
    }

Aquí lo configuramos en JOB_VIEW_FULL para los fines de este codelab, ya que la cantidad de trabajos que se consultan (y la cantidad de usuarios simultáneos) es bastante baja, y nos permite examinar los diferentes campos disponibles con mayor facilidad. En producción, te recomendamos usar una JobView con una carga útil más ligera cuando compiles un índice de resultados de búsqueda, ya que llevará menos ancho de banda innecesario.

Paginación

Como puede obtener muchos resultados, la API también se paginará, de modo que pueda trabajar con una interfaz de paginación. Te recomendamos mantener el tamaño de la página en 20 o menos para evitar problemas de latencia y usar siempre la paginación a través de la API en lugar de cargar todos los resultados. Si hay más trabajos, recibirás un nextPageToken en la respuesta, de manera que puedas pasarlo al siguiente token de búsqueda y la siguiente página.

Una vez más, este ajuste de los resultados de la búsqueda se realiza agregando un solo campo a la solicitud y especificando cuántos resultados de la búsqueda desea por página.

    request = {
        'requestMetadata': request_metadata,
        'jobQuery': job_query,
        'jobView' : 'JOB_VIEW_FULL',
        'pageSize': 1
    }

Pruebe ejecutar su secuencia de comandos search_jobs con el pageSize especificado en 1 en la solicitud. Si lo ejecutas, solo obtendrás un resultado de búsqueda. Sin embargo, tienes más de una publicación de empleo en tu base de datos. ¿Cómo se duerme?

Cuando la respuesta actual contenga más resultados de los que contiene, aparecerá un campo nextPageToken en la respuesta. Tome ese valor, guárdelo en su solicitud existente con el nombre pageToken y vuelva a ejecutar la búsqueda. A continuación, se muestra un ejemplo de cómo hacerlo.

    if "nextPageToken" in response:
        request["pageToken"] = response.get('nextPageToken')
        response = client_service.projects().jobs().search(
            parent=project_id, body=request).execute()
        for job in response.get('matchingJobs'):
            print('%s: %s' % (job.get('job').get('title'),
                                job.get('searchTextSnippet')))

Corrector ortográfico automático de la consulta

La función de corrector ortográfico está integrada en la API. Por lo tanto, si tu usuario busca la palabra "administrador" se mostrará en los resultados con fichas de la palabra "administrador".

Esta función está habilitada de forma predeterminada. Si desea inhabilitarlo, agregue el campo disableSpellCheck a su objeto JobQuery y configúrelo como verdadero.

search_jobs.py

job_query = {
   'query': "Enginer",
   'disableSpellCheck': "true"
}

Intenta ejecutar esta función. Si la marca no está presente, "Engineer" mostrará los resultados que contengan la string "Engineer". Si el corrector ortográfico está inhabilitado, la misma consulta mostrará 0 resultados.

A continuación, analizaremos algunas maneras de ajustar la relevancia de los resultados de la búsqueda.

La API de Job Search de Google Cloud Talent Solution usa el aprendizaje automático (AA) para determinar la relevancia de las fichas de trabajos cuando un usuario está buscando trabajos.

Jobs y las empresas tienen varias propiedades a las que hacen referencia los modelos de aprendizaje automático para determinar la relevancia de los resultados de la búsqueda. Puedes influir en esa relevancia de forma significativa si proporcionas más información o usas elementos como empleos destacados. Por supuesto, la relevancia del resultado de la búsqueda puede ser difícil de medir, especialmente porque diferentes elementos son relevantes para distintos usuarios. La API de Job Search utiliza un algoritmo basado en algunos indicadores de los datos del trabajo. Veamos cómo algunos de estos indicadores influyen en los resultados de la búsqueda.

Los trabajos destacados te permiten influir en los resultados de la búsqueda de tus usuarios mediante la clasificación de los trabajos en función del valor de la promoción, en lugar de solo por relevancia. Cuando realizas una búsqueda de trabajos destacados, solo se muestran trabajos relevantes con un valor de promoción asignado.

Los trabajos destacados son útiles en los casos en los que desees tener el patrocinio de trabajos individuales en tu índice. Por ejemplo, un sitio de búsqueda de empleo que promociona trabajos fundamentales para empresas puede utilizar la búsqueda de trabajos destacados a fin de mostrar solo trabajos patrocinados a quienes buscan empleo.

Para definir un trabajo como "featured" (destacado), se usa un campo promotionValue en la definición del trabajo cuando se crea o actualiza un trabajo. En la secuencia de comandos create_some_jobs.py que usamos antes en este codelab, se creó uno de los trabajos con un valor de promoción. Volvamos a ver el fragmento con la línea correspondiente en los comentarios:

create_some_jobs.py;

   job = {
       'company_name': company_name,
       'title': 'Test Engineer',
       'description':
       """Hiring Test engineer for full-time position with Tandem.  Must be detail oriented
       and (obviously) comfortable with pair programming..
       <p />Join Tandem today!""",
       'requisition_id': 'tandem_te',
       'application_info': {
           'uris': ['http://www.example.com/tandem/test-engineer'],
           'emails': ['apply-tandem-test@example.com']
       },
       # Down here vvvvv
       'promotionValue': 1
       # Up there ^^^^^
   }

Ese valor de promoción puede ser cualquier número entero entre 1 y 10. Cuando cambias el modo de búsqueda a FEATURED_JOB_SEARCH (verás cómo hacerlo a continuación), los resultados de la búsqueda se ven afectados de dos maneras:

  • Solo se mostrarán los trabajos que tengan un valor de promotionalValue > 0
  • Los trabajos se ordenarán de forma descendente, con el valor promotionalValue. Los trabajos con el mismo promotionalValue se ordenarán por relevancia (según lo determine el algoritmo de búsqueda).
   request = {
       'searchMode': 'FEATURED_JOB_SEARCH',
       'requestMetadata': request_metadata,
       'jobQuery': job_query,
       'jobView' : 'JOB_VIEW_FULL'
   }

Actualiza tu solicitud para establecer el modo de búsqueda en FEATURED_JOB_SEARCH. Luego, ejecuta el código. Deberías ver un resultado similar al siguiente:

$ $ python search_jobs.py
Search Results:
Test Engineer: Hiring Test <b>engineer</b> for full-time position with Tandem. Must be detail oriented
and (obviously) comfortable with pair programming.. Join Tandem today!

El único trabajo con un valor promocional que se establece explícitamente en 0.

Ubicación geográfica

Una de las propiedades más importantes es la ubicación geográfica. Tanto empresas como trabajos tienen propiedades de ubicación, pero la ubicación se usará sobre la de la empresa cuando un usuario realice una búsqueda. Debes usar el campo de dirección específico para trabajos y empresas a fin de que la API pueda usar la ubicación geográfica a fin de mostrar los trabajos más relevantes para una búsqueda. Si alguien busca "San Francisco" probablemente desee ver primero los trabajos en San Francisco y los alrededores.

En nuestros trabajos de ejemplo, el puesto de ingeniero de software sénior en FooCorp tiene un campo de ubicación establecido en Mountain View, California. El código que hace esto (por si no quieres retroceder una página y realizar una búsqueda) tiene el siguiente aspecto:

create_some_jobs.py (donde la ubicación se define en FooCorp)

...
    job = {
        'company_name': company_name,
        'title': 'Senior Software Engineer',
        'addresses': ["Mountain View, CA"],
...

Un nombre de ciudad funciona bien, pero usa una dirección completa para obtener mejores resultados.

Aunque es técnicamente opcional, agregar una ubicación proporciona muchas funcionalidades útiles para el usuario que busca empleo. El CTS convertirá esa dirección a una latitud y longitud, y la utilizará como indicador de búsqueda. Por ejemplo, a continuación, te mostramos cómo ajustarías tu JobQuery para ejecutar una búsqueda de trabajos en el área de Palo Alto, con una distancia máxima de, 10 millas:

search_jobs.py (búsqueda de trabajos en/cerca de Palo Alto)

...
location_filter = {
   'address': 'Palo Alto',
   'distance_in_miles': 10,
   }

job_query = {
   'location_filters': [location_filter],
   'query': "Engineer",
}
...

Ejecuta ese código teniendo en cuenta que en ninguna parte de nuestro código de creación de trabajo mencionamos a Palo Alto una vez. No hay descripciones de trabajos, nombre de la empresa, nada.

$ python search_jobs.py
Search Results:
Senior Software Engineer: Experienced software <b>engineer</b> required for full-time position. Leadership ability
and ability to thrive in highly competitive environment a must. Ignore postings
from that &quot;Bar&quot; company, their microkitchen&nbsp;...

Se mostró un resultado. Debido a que Palo Alto se encuentra a 16 km del trabajo (16 km es el límite que definiste en LocationFilter)

Hay otras cosas divertidas que puedes hacer con la ubicación que están fuera del alcance de este codelab. Le recomendamos que explore lo siguiente:

Palabras clave y ampliación

El título y la descripción del puesto desempeñan un papel importante a la hora de determinar si es adecuado para una búsqueda, por supuesto. Si se publicó un trabajo para un maestro de scrum y en la descripción se menciona la tarea de administrar desarrolladores de software, la búsqueda de un administrador de desarrollo de software debería incluir esa búsqueda. Asegúrate de no ingresar varias palabras clave en la descripción de un empleo o podrías ver anuncios menos relevantes.

La API también tiene algunos parámetros que puede pasar cuando realiza una búsqueda para controlar mejor los resultados. La concordancia de palabras clave le permite habilitar o inhabilitar si la búsqueda debe buscar palabras clave más allá de los resultados normales basados en el AA. También relajará algunos de los filtros específicos de la ubicación. Si amplías el alcance de la búsqueda para los parámetros determinados, podrás obtener más resultados de una búsqueda.

Este es un ejemplo de cómo funciona eso. En primer lugar, sin habilitar la ampliación, realiza una búsqueda con el término de consulta "Agile". Si usaste la secuencia de comandos proporcionada en este codelab para crear tus empresas y trabajos, no aparecerá nada. ¿Por qué? Porque la palabra "ágil" no se encuentra en ninguna de las fichas. Sin embargo, es una metodología de programación popular asociada con los trabajos de ingeniería.

Habilitemos la ampliación de palabras clave y observemos los cambios.

search_jobs.py (con la ampliación habilitada)

...
job_query = {
    'query': "Agile",
}

request = {
    'requestMetadata': request_metadata,
    'jobQuery': job_query,
    'jobView' : 'JOB_VIEW_FULL',
    'enableBroadening' : True
}
...

Ahora vuelva a ejecutar la secuencia de comandos. Esta vez verá algunos resultados.

$ python search_jobs.py
Search Results:
Junior Software Engineer: Hiring entry level software engineer required for full-time position. Must be
passionate about industry intersection of horses and technology. Ability to
intelligently discuss the equine singularity a major&nbsp;...

Senior Software Engineer: Experienced software engineer required for full-time position. Leadership ability
and ability to thrive in highly competitive environment a must. Ignore postings
from that &quot;Bar&quot; company, their microkitchen&nbsp;...

Test Engineer: Hiring Test engineer for full-time position with Tandem. Must be detail oriented
and (obviously) comfortable with pair programming.. Join Tandem today!

Ahora, ¿cómo sabemos que no es solo una bandera general para devolver todo? Intenta reemplazar "Ágil" con algunos sinónimos, como "sprightly""dexterous", "lively" o "swift". En todos los casos, no aparece nada.

Sin embargo, la habilitación de la ampliación es una desventaja. La página de prácticas recomendadas para la búsqueda de trabajo indica claramente que la habilitación de este parámetro aumenta la cantidad de resultados de la búsqueda, pero puede reducir la relevancia general de los resultados. Básicamente, esta función corre el riesgo de sumar cantidad a costa de la calidad. Por otro lado, también podría ayudar a tu usuario a encontrar algo que no sabía cómo expresar correctamente.

Diversificación

A veces, se muestran varios trabajos muy similares entre sí en los resultados de la búsqueda. Esto puede tener un efecto adverso para el usuario, ya que evita que vea la variedad de resultados disponible.

La función de diversificación corrige este problema. Los trabajos se identifican como similares según su título, categoría y ubicación. Los resultados muy similares se agrupan en clústeres para que solo se muestre un trabajo del clúster más arriba en los resultados de la búsqueda. Es posible que hayas notado que, cuando buscaste "Engineer", obtuviste resultados como los siguientes:

$ python search_jobs.py
Test Engineer ...
Senior Software Engineer ...
Junior Software Engineer ...
Test Engineer ...

¿Por qué se pidió de esa forma? Los trabajos de ingeniero de software pertenecen a dos empresas (HorseHub y FooCorp) y tienen descripciones diferentes. Ambos son trabajos de ingeniería de software, pero son lo suficientemente diferentes como para justificar la cercanía en los resultados.

Sin embargo, si observas las fichas de ingeniería de pruebas, se trata exactamente de la misma ficha publicada para la misma empresa dos veces. Dado que la diversificación está habilitada de forma predeterminada, la segunda ficha del ingeniero de pruebas se consideró menos importante (aunque es técnicamente más relevante) que otras fichas potencialmente más interesantes.

El nivel de diversidad en realidad tiene 3 opciones posibles, pero solo tendrás que elegir una de manera explícita. Son las siguientes:

  • DIVERSIFICATION_LEVEL_UNSPECIFIED: Solo significa que no especificaste un nivel y este debe hacer lo que sea el predeterminado (por el momento, el comportamiento predeterminado es el mismo que el de SIMPLE).
  • INHABILITADA: Inhabilita la diversificación. No se modificará su posición para los trabajos que normalmente se deberían enviar a la última página por ser muy similares.
  • SIMPLE: comportamiento predeterminado de diversificación. La lista de resultados está ordenada para que los resultados altamente similares se envíen al final de la última página de resultados de la búsqueda.

Aquí te mostramos cómo debes configurar explícitamente el nivel de diversificación de tu solicitud. Al igual que la mayoría de los demás ajustes en los ajustes que hicimos en este codelab, todo lo que debes hacer es ajustar tu solicitud. Pruebe los siguientes parámetros de configuración para su consulta y solicitud de trabajo, lo que inhabilitará la diversificación y establecerá el término de búsqueda como "Ingeniero"

search_jobs.py (nivel de diversificación)

job_query = {
    'query': "Engineer",
}

# 2) Throw RequestMetadata object in a request
request = {
    'requestMetadata': request_metadata,
    'jobQuery': job_query,
    'jobView' : 'JOB_VIEW_FULL',
    'diversificationLevel': 'DISABLED'
}

Ejecuta search_jobs.py ahora y observarás un orden ligeramente diferente: los trabajos de los ingenieros de prueba ahora están más cerca.

$python search_jobs.py
Test Engineer: Hiring Test <b>Engineer</b> for full-time position with Tandem. Must be detail oriented
and (obviously) comfortable with pair programming. Will be working with team of
Software Engineers. Join Tandem today!

Test Engineer: Hiring Test <b>Engineer</b> for full-time position with Tandem. Must be detail oriented
and (obviously) comfortable with pair programming. Will be working with team of
Software Engineers. Join Tandem today!

Software Engineer: Experienced software <b>engineer</b> required for full-time position. Leadership ability
and ability to thrive in highly competitive environment a must. Ignore postings
from that &quot;Bar&quot; company, their microkitchen&nbsp;...

Software Engineer: Hiring entry level software <b>engineer</b> required for full-time position. Must be
passionate about industry intersection of horses and technology. Ability to
intelligently discuss the equine singularity a major&nbsp;...

Aprendiste cómo consultar empleos con la API de Job Search.

Temas abordados

  • Configura tu proyecto de Cloud
  • Configura tu entorno de desarrollo
  • Consulta trabajos
  • Agrega un objeto JobQuery con parámetros de búsqueda
  • Cómo limitar la cantidad de datos que se muestran mediante jobView
  • Paginación
  • Corrector ortográfico automático de la consulta
  • Trabajos destacados
  • Cómo realizar ajustes para la relevancia de búsqueda
  • Ubicación geográfica
  • Palabras clave y ampliación
  • Diversificación

Más información