paulvanderlaken.com
Open in
urlscan Pro
192.0.78.24
Public Scan
Submitted URL: http://paulvanderlaken.com/
Effective URL: https://paulvanderlaken.com/
Submission: On December 08 via api from US — Scanned from DE
Effective URL: https://paulvanderlaken.com/
Submission: On December 08 via api from US — Scanned from DE
Form analysis 6 forms found in the DOM
https://paulvanderlaken.com/
<form id="header-search" action="https://paulvanderlaken.com/">
<input type="search" class="search-field" name="s" value="">
<button type="submit" class="search-button">Search</button>
</form>GET https://paulvanderlaken.com/
<form role="search" method="get" class="search-form" action="https://paulvanderlaken.com/">
<label>
<span class="screen-reader-text">Search for:</span>
<input type="search" class="search-field" placeholder="Search …" value="" name="s">
</label>
<input type="submit" class="search-submit" value="Search">
</form>POST https://subscribe.wordpress.com
<form action="https://subscribe.wordpress.com" method="post" accept-charset="utf-8" data-blog="122868229" data-post_access_level="everybody" id="subscribe-blog">
<p>Receive notifications of new content.</p>
<p id="subscribe-email">
<label id="subscribe-field-label" for="subscribe-field" class="screen-reader-text"> Email Address: </label>
<input type="email" name="email" style="width: 95%; padding: 1px 10px" placeholder="Email Address" value="" id="subscribe-field" required="">
</p>
<p id="subscribe-submit">
<input type="hidden" name="action" value="subscribe">
<input type="hidden" name="blog_id" value="122868229">
<input type="hidden" name="source" value="https://paulvanderlaken.com/">
<input type="hidden" name="sub-type" value="widget">
<input type="hidden" name="redirect_fragment" value="subscribe-blog">
<input type="hidden" id="_wpnonce" name="_wpnonce" value="0dcbdb6aac"> <button type="submit" class="wp-block-button__link"> Follow </button>
</p>
</form>GET https://paulvanderlaken.com
<form action="https://paulvanderlaken.com" method="get"><label class="screen-reader-text" for="cat">Browse Archives</label><select name="cat" id="cat" class="postform">
<option value="-1">Select Category</option>
<option class="level-0" value="3370">application (57)</option>
<option class="level-0" value="44070">automation (44)</option>
<option class="level-0" value="2185">best practices (59)</option>
<option class="level-0" value="33525">conference (13)</option>
<option class="level-0" value="630657">cyber security (2)</option>
<option class="level-0" value="129522">datasets (6)</option>
<option class="level-0" value="1131271">deep learning (37)</option>
<option class="level-0" value="148">design (21)</option>
<option class="level-0" value="384">entertainment (57)</option>
<option class="level-0" value="8289">ethics (8)</option>
<option class="level-0" value="449">experiment (16)</option>
<option class="level-0" value="4269">finance (2)</option>
<option class="level-0" value="3590">gadget (1)</option>
<option class="level-0" value="39956">hr (27)</option>
<option class="level-0" value="688756943">java (9)</option>
<option class="level-0" value="457">javascript (29)</option>
<option class="level-0" value="264">learning (95)</option>
<option class="level-0" value="40978">machine learning (85)</option>
<option class="level-0" value="103">news (12)</option>
<option class="level-0" value="196">programming (37)</option>
<option class="level-0" value="832">python (59)</option>
<option class="level-0" value="10189">r (134)</option>
<option class="level-0" value="1473">reading (17)</option>
<option class="level-0" value="101572">reinforcement learning (4)</option>
<option class="level-0" value="17573">report (11)</option>
<option class="level-0" value="668">research (42)</option>
<option class="level-0" value="5849">statistics (75)</option>
<option class="level-0" value="186779">text mining (27)</option>
<option class="level-0" value="1981">tools (33)</option>
<option class="level-0" value="44111">visualization (139)</option>
</select>
</form>POST https://subscribe.wordpress.com
<form method="post" action="https://subscribe.wordpress.com" accept-charset="utf-8" style="display: none;">
<div class="actnbr-follow-count">Join 379 other followers</div>
<div>
<input type="email" name="email" placeholder="Enter your email address" class="actnbr-email-field" aria-label="Enter your email address">
</div>
<input type="hidden" name="action" value="subscribe">
<input type="hidden" name="blog_id" value="122868229">
<input type="hidden" name="source" value="https://paulvanderlaken.com/">
<input type="hidden" name="sub-type" value="actionbar-follow">
<input type="hidden" id="_wpnonce" name="_wpnonce" value="0dcbdb6aac">
<div class="actnbr-button-wrap">
<button type="submit" value="Sign me up"> Sign me up </button>
</div>
</form><form id="jp-carousel-comment-form">
<label for="jp-carousel-comment-form-comment-field" class="screen-reader-text">Write a Comment...</label>
<textarea name="comment" class="jp-carousel-comment-form-field jp-carousel-comment-form-textarea" id="jp-carousel-comment-form-comment-field" placeholder="Write a Comment..."></textarea>
<div id="jp-carousel-comment-form-submit-and-info-wrapper">
<div id="jp-carousel-comment-form-commenting-as">
<fieldset>
<label for="jp-carousel-comment-form-email-field">Email (Required)</label>
<input type="text" name="email" class="jp-carousel-comment-form-field jp-carousel-comment-form-text-field" id="jp-carousel-comment-form-email-field">
</fieldset>
<fieldset>
<label for="jp-carousel-comment-form-author-field">Name (Required)</label>
<input type="text" name="author" class="jp-carousel-comment-form-field jp-carousel-comment-form-text-field" id="jp-carousel-comment-form-author-field">
</fieldset>
<fieldset>
<label for="jp-carousel-comment-form-url-field">Website</label>
<input type="text" name="url" class="jp-carousel-comment-form-field jp-carousel-comment-form-text-field" id="jp-carousel-comment-form-url-field">
</fieldset>
</div>
<input type="submit" name="submit" class="jp-carousel-comment-form-button" id="jp-carousel-comment-form-button-submit" value="Post Comment">
</div>
</form>Text Content
Skip to content
Disentangling Data Science
Search
* LinkedIn
* Twitter
* ResearchGate
PAULVANDERLAKEN.COM
Menu
* Blog
* About
* Contact
* Blog
* About
* Contact
GETTING CHATGPT TO SIMULATE A RECRUITMENT PROCESS IN PYTHON CODE
I was playing around with ChatGPT to see if it could write Python code to
generate realistic recruitment process data for me.
Here’s the full conversation as I was truly amazed with the results.
I emboldened my prompts and had to ask ChatGPT to continue sometimes as longer
responses are cut off.
Can you write Python code that simulates how applications would be processed
through a recruitment funnel, with a class that stores all timestamps?
Sure! Here is a simple example of how you could simulate the processing of
applications through a recruitment funnel using Python:
Copy code# Define a class that represents an application
class Application:
def __init__(self):
self.timestamps = []
# This method will be called each time an application moves to the next stage
# of the recruitment funnel
def update_timestamp(self):
self.timestamps.append(datetime.now())
# Define a function that simulates the processing of applications through the
# recruitment funnel
def process_applications(applications):
# Loop through each application in the list
for application in applications:
# Simulate processing the application (e.g. reviewing the resume)
time.sleep(1)
application.update_timestamp()
# Simulate moving the application to the next stage of the recruitment
# funnel (e.g. scheduling an interview)
time.sleep(1)
application.update_timestamp()
# Simulate completing the final stage of the recruitment funnel
# (e.g. making a job offer)
time.sleep(1)
application.update_timestamp()
# Create a list of applications
applications = [Application() for _ in range(10)]
# Simulate processing the applications through the recruitment funnel
process_applications(applications)
# Print the timestamps for each application
for application in applications:
print(application.timestamps)
In this example, the Application class has a timestamps attribute that stores a
list of timestamps representing each time the application moves to the next
stage of the recruitment funnel. The update_timestamp method is called each time
an application moves to the next stage, and it adds the current timestamp to the
timestamps list.
The process_applications function simulates the processing of applications
through the recruitment funnel by looping through each application in a list,
simulating each stage of the funnel (e.g. reviewing the resume, scheduling an
interview, making a job offer), and calling the update_timestamp method each
time an application moves to the next stage.
At the end, the code prints the timestamps for each application to show how the
timestamps are recorded as the applications move through the recruitment funnel.
The recruitment funnel process should include the following steps: application,
resume review, telephone interview, assessment, interview, contract offer,
acceptance.
Sure, here is a revised version of the code that includes the additional steps
in the recruitment funnel process:
Copy code# Define a class that represents an application
class Application:
def __init__(self):
self.timestamps = []
# This method will be called each time an application moves to the next stage
# of the recruitment funnel
def update_timestamp(self):
self.timestamps.append(datetime.now())
# Define a function that simulates the processing of applications through the
# recruitment funnel
def process_applications(applications):
# Loop through each application in the list
for application in applications:
# Simulate receiving the application
time.sleep(1)
application.update_timestamp()
# Simulate reviewing the resume
time.sleep(1)
application.update_timestamp()
# Simulate conducting a telephone interview
time.sleep(1)
application.update_timestamp()
# Simulate conducting an assessment
time.log(1)
application.update_timestamp()
# Simulate conducting an in-person interview
time.sleep(1)
application.update_timestamp()
# Simulate making a contract offer
time.sleep(1)
application.update_timestamp()
# Simulate accepting the contract offer
time.sleep(1)
application.update_timestamp()
# Create a list of applications
applications = [Application() for _ in range(10)]
# Simulate processing the applications through the recruitment funnel
process_applications(applications)
# Print the timestamps for each application
for application in applications:
print(application.timestamps)
In this revised version, the process_applications function simulates each step
of the recruitment funnel process, including receiving the application,
reviewing the resume, conducting a telephone interview, conducting an
assessment, conducting an in-person interview, making a contract offer, and
accepting the contract offer. Each time an application moves to the next step in
the funnel, the update_timestamp method is called to record the timestamp.
At the end, the code prints the timestamps for each application to show how they
are recorded as the applications move through the recruitment funnel.
Can you use the simpy module instead?
Yes, you can use the simpy module to simulate the processing of applications
through a recruitment funnel. Here is an example of how you could do this using
simpy:
Copy codeimport simpy
import random
# Define a class that represents an application
class Application:
def __init__(self):
self.timestamps = []
# This method will be called each time an application moves to the next stage
# of the recruitment funnel
def update_timestamp(self, env):
self.timestamps.append(env.now)
# Define a function that simulates the processing of applications through the
# recruitment funnel
def process_applications(env, applications):
# Loop through each application in the list
for application in applications:
# Simulate receiving the application
yield env.timeout(1)
application.update_timestamp(env)
# Simulate reviewing the resume
yield env.timeout(1)
application.update_timestamp(env)
# Simulate conducting a telephone interview
yield env.timeout(1)
application.update_timestamp(env)
# Simulate conducting an assessment
yield env.timeout(1)
application.update_timestamp(env)
# Simulate conducting an in-person interview
yield env.timeout(1)
application.update_timestamp(env)
# Simulate making a contract offer
yield env.timeout(1)
application.update_timestamp(env)
# Simulate accepting the contract offer
yield env.timeout(1)
application.update_timestamp(env)
# Create a simpy environment
env = simpy.Environment()
# Create a list of applications
applications = [Application() for _ in range(10)]
# Simulate processing the applications through the recruitment funnel
env.process(process_applications(env, applications))
env.run()
# Print the timestamps for each application
for application in applications:
print(application.timestamps)
In this example, the process_applications function uses yield statements and the
env.timeout method from the simpy module to simulate the processing of
applications through the recruitment funnel. Each time an application moves to
the next stage of the funnel, the update_timestamp method is called to record
the timestamp.
At the end, the code prints the timestamps for each application to show how they
are recorded as the applications move through the recruitment funnel.
I need the code to also log the name of the process step.
Sure, here is an updated version of the code that also logs the name of the
process step each time an application moves to the next stage of the recruitment
funnel:
Copy codeimport simpy
import random
# Define a class that represents an application
class Application:
def __init__(self):
self.timestamps = []
# This method will be called each time an application moves to the next stage
# of the recruitment funnel
def update_timestamp(self, env, process_name):
self.timestamps.append((env.now, process_name))
# Define a function that simulates the processing of applications through the
# recruitment funnel
def process_applications(env, applications):
# Loop through each application in the list
for application in applications:
# Simulate receiving the application
yield env.timeout(1)
application.update_timestamp(env, "Received")
# Simulate reviewing the resume
yield env.timeout(1)
application.update_timestamp(env, "Resume Review")
# Simulate conducting a telephone interview
yield env.timeout(1)
application.update_timestamp(env, "Telephone Interview")
# Simulate conducting an assessment
yield env.timeout(1)
application.update_timestamp(env, "Assessment")
# Simulate conducting an in-person interview
yield env.timeout(1)
application.update_timestamp(env, "Interview")
# Simulate making a contract offer
yield env.timeout(1)
application.update_timestamp(env, "Contract Offer")
# Simulate accepting the contract offer
yield env.timeout(1)
application.update_timestamp(env, "Acceptance")
# Create a simpy environment
env = simpy.Environment()
# Create a list of applications
applications = [Application() for _ in range(10)]
# Simulate processing the applications through the recruitment funnel
env.process(process_applications(env, applications))
env.run()
# Print the timestamps and process names for each application
for application in applications:
print(application.timestamps)
In this updated version, the update_timestamp method takes an additional
argument process_name that represents the name of the process step. Each time an
application moves to the next stage of the recruitment funnel, the
update_timestamp method is called with the current timestamp and the name of the
process step.
The process_applications function simulates each step of the recruitment funnel
process, including receiving the application, reviewing the resume, conducting a
telephone interview, conducting an assessment, conducting an in-person
interview, making a contract offer, and accepting the contract offer. Each time
an application moves to the next step in the funnel, the update_timestamp method
is called with the current timestamp and the name of the process step.
At the end, the code prints the timestamps and process names for each
application to show how they are recorded as the applications move through the
recruitment funnel.
Can you have it simulate 900 applicants with unique names and birthdays?
Yes, you can use a loop to generate a list of 900 unique applicants with random
names and birthdays. Here is an example of how you could do this using the faker
library to generate random names and dates:
Copy codeimport simpy
import random
from faker import Faker
# Define a class that represents an application
class Application:
def __init__(self, name, birthday):
self.name = name
self.birthday = birthday
self.timestamps = []
# This method will be called each time an application moves to the next stage
# of the recruitment funnel
def update_timestamp(self, env, process_name):
self.timestamps.append((env.now, process_name))
# Define a function that simulates the processing of applications through the
# recruitment funnel
def process_applications(env, applications):
# Loop through each application in the list
for application in applications:
# Simulate receiving the application
yield env.timeout(1)
application.update_timestamp(env, "Received")
# Simulate reviewing the resume
yield env.timeout(1)
application.update_timestamp(env, "Resume Review")
# Simulate conducting a telephone interview
yield env.timeout(1)
application.update_timestamp(env, "Telephone Interview")
# Simulate conducting an assessment
yield env.timeout(1)
application.update_timestamp(env, "Assessment")
# Simulate conducting an in-person interview
yield env.timeout(1)
application.update_timestamp(env, "Interview")
# Simulate making a contract offer
yield env.timeout(1)
application.update_timestamp(env, "Contract Offer")
# Simulate accepting the contract offer
yield env.timeout(1)
application.update_timestamp(env, "Acceptance")
# Create a simpy environment
env = simpy.Environment()
# Create a list of applications
applications = []
# Generate random names and birthdays for each application
fake = Faker()
for i in range(900):
name = fake.name()
birthday = fake.date_of_birth()
applications.append(Application(name, birthday))
# Simulate processing the applications through the recruitment funnel
env.process(process_applications(env, applications))
env.run()
# Print the timestamps and process names for each application
for application in applications:
print(application.timestamps)
In this example, the Application class has additional name and birthday
attributes that store the name and birthday of each applicant. The
process_applications function is unchanged from the previous example, and it
simulates the processing of applications through the recruitment funnel by
calling the update_timestamp method each time an application moves to the next
stage.
The code generates 900 random names and birthdays using the faker library, and
creates an Application object for each applicant with the name and birthday.
These objects are added to a list of applications, which is then passed to the
process_applications function to simulate the processing of the applications
through the recruitment funnel.
At the end, the code prints the timest
I want the code to put all the applicants data into a csv file and save the
file.
Sure, here is an updated version of the code that saves the applicants’ data to
a CSV file:
Copy codeimport simpy
import random
import csv
from faker import Faker
# Define a class that represents an application
class Application:
def __init__(self, name, birthday):
self.name = name
self.birthday = birthday
self.timestamps = []
# This method will be called each time an application moves to the next stage
# of the recruitment funnel
def update_timestamp(self, env, process_name):
self.timestamps.append((env.now, process_name))
# Define a function that simulates the processing of applications through the
# recruitment funnel
def process_applications(env, applications):
# Loop through each application in the list
for application in applications:
# Simulate receiving the application
yield env.timeout(1)
application.update_timestamp(env, "Received")
# Simulate reviewing the resume
yield env.timeout(1)
application.update_timestamp(env, "Resume Review")
# Simulate conducting a telephone interview
yield env.timeout(1)
application.update_timestamp(env, "Telephone Interview")
# Simulate conducting an assessment
yield env.timeout(1)
application.update_timestamp(env, "Assessment")
# Simulate conducting an in-person interview
yield env.timeout(1)
application.update_timestamp(env, "Interview")
# Simulate making a contract offer
yield env.timeout(1)
application.update_timestamp(env, "Contract Offer")
# Simulate accepting the contract offer
yield env.timeout(1)
application.update_timestamp(env, "Acceptance")
# Create a simpy environment
env = simpy.Environment()
# Create a list of applications
applications = []
# Generate random names and birthdays for each application
fake = Faker()
for i in range(900):
name = fake.name()
birthday = fake.date_of_birth()
applications.append(Application(name, birthday))
# Simulate processing the applications through the recruitment funnel
env.process(process_applications(env, applications))
env.run()
# Save the applicants' data to a CSV file
with open("applicants.csv", "w") as csvfile:
writer = csv.writer(csvfile)
# Write the header row
writer.writerow(["Name", "Birthday", "Timestamps"])
# Write the data for each applicant
for application in applications:
writer.writerow([application.name, application.birthday, application.timestamps])
In this updated version, the code uses the csv module to save the applicants’
data to a CSV file. It creates a csv.writer object, which is used to write the
data to the file. The code writes the header row, which includes the column
names “Name”, “Birthday”, and “Timestamps”. Then, it writes a row of
Please also create an applicant class to store and process their information.
Sure, here is an updated version of the code that uses an Applicant class to
store and process applicants’ data:
Copy codeimport simpy
import random
import csv
from faker import Faker
# Define a class that represents an applicant
class Applicant:
def __init__(self, name, birthday):
self.name = name
self.birthday = birthday
self.timestamps = []
# This method will be called each time an applicant moves to the next stage
# of the recruitment funnel
def update_timestamp(self, env, process_name):
self.timestamps.append((env.now, process_name))
# Define a function that simulates the processing of applicants through the
# recruitment funnel
def process_applicants(env, applicants):
# Loop through each applicant in the list
for applicant in applicants:
# Simulate receiving the applicant's application
yield env.timeout(1)
applicant.update_timestamp(env, "Received")
# Simulate reviewing the applicant's resume
yield env.timeout(1)
applicant.update_timestamp(env, "Resume Review")
# Simulate conducting a telephone interview with the applicant
yield env.timeout(1)
applicant.update_timestamp(env, "Telephone Interview")
# Simulate conducting an assessment of the applicant
yield env.timeout(1)
applicant.update_timestamp(env, "Assessment")
# Simulate conducting an in-person interview with the applicant
yield env.timeout(1)
applicant.update_timestamp(env, "Interview")
# Simulate making a contract offer to the applicant
yield env.timeout(1)
applicant.update_timestamp(env, "Contract Offer")
# Simulate accepting the contract offer from the applicant
yield env.timeout(1)
applicant.update_timestamp(env, "Acceptance")
# Create a simpy environment
env = simpy.Environment()
# Create a list of applicants
applicants = []
# Generate random names and birthdays for each applicant
fake = Faker()
for i in range(900):
name = fake
Continue from the applicants = []
Sure, here is the updated code that continues from the applicants = [] line:
Copy code# Generate random names and birthdays for each applicant
fake = Faker()
for i in range(900):
name = fake.name()
birthday = fake.date_of_birth()
applicants.append(Applicant(name, birthday))
# Simulate processing the applicants through the recruitment funnel
env.process(process_applicants(env, applicants))
env.run()
# Save the applicants' data to a CSV file
with open("applicants.csv", "w") as csvfile:
writer = csv.writer(csvfile)
# Write the header row
writer.writerow(["Name", "Birthday", "Timestamps"])
# Write the data for each applicant
for applicant in applicants:
writer.writerow([applicant.name, applicant.birthday, applicant.timestamps])
This code creates a list of Applicant objects using random names and birthdays
generated with the faker library. Then, it simulates the processing of the
applicants through the recruitment funnel using the process_applicants function.
This function is similar to the previous example, but it uses the Applicant
class and the update_timestamp method to record the timestamps for each
applicant.
Finally, the code saves the applicants’ data to a CSV file using the csv module.
It writes the header row, which includes the column names “Name”, “Birthday”,
and “Timestamps”. Then, it writes a row of data for each applicant, which
includes the applicant’s name, birthday, and timestamps.
With this code, you can simulate the processing of applicants through a
recruitment funnel, and save their data to a CSV file for further analysis.
make the name and birthday generation process part of the Applicant class
Sure, here is an updated version of the code that uses the Applicant class to
generate random names and birthdays for each applicant:
Copy codeimport simpy
import random
import csv
from faker import Faker
# Define a class that represents an applicant
class Applicant:
def __init__(self):
self.name = fake.name()
self.birthday = fake.date_of_birth()
self.timestamps = []
# This method will be called each time an applicant moves to the next stage
# of the recruitment funnel
def update_timestamp(self, env, process_name):
self.timestamps.append((env.now, process_name))
# Define a function that simulates the processing of applicants through the
# recruitment funnel
def process_applicants(env, applicants):
# Loop through each applicant in the list
for applicant in applicants:
# Simulate receiving the applicant's application
yield env.timeout(1)
applicant.update_timestamp(env, "Received")
# Simulate reviewing the applicant's resume
yield env.timeout(1)
applicant.update_timestamp(env, "Resume Review")
# Simulate conducting a telephone interview with the applicant
yield env.timeout(1)
applicant.update_timestamp(env, "Telephone Interview")
# Simulate conducting an assessment of the applicant
yield env.timeout(1)
applicant.update_timestamp(env, "Assessment")
# Simulate conducting an in-person interview with the applicant
yield env.timeout(1)
applicant.update_timestamp(env, "Interview")
# Simulate making a contract offer to the applicant
yield env.timeout(1)
applicant.update_timestamp(env, "Contract Offer")
# Simulate accepting the contract offer from the applicant
yield env.timeout(1)
applicant.update_timestamp(env, "Acceptance")
# Create a simpy environment
env = simpy.Environment()
# Create a list of applicants
applicants = []
# Create a fake object to generate random names and birthdays
fake = Faker()
# Create 900 applicants with random names and birthdays
for i in range(900):
applicants.append(Applicant())
# Simulate processing the applicants through the recruitment funnel
env.process(process_applicants(env, applicants))
env.run()
# Save the applicants' data to a CSV file
with open("applicants.csv", "w") as csvfile:
writer = csv.writer(csvfile)
# Write the header row
writer.writerow(["Name", "Birthday", "Timestamps"])
# Write the data for each applicant
for applicant in applicants:
Rewrite the code so that it is of better quality, and unpack the timestamps in
the csv file to be stored in individual columns.
Sure, here is an updated version of the code that improves the quality and
structure of the code, and unpacks the timestamps into individual columns in the
CSV file:
Copy codeimport simpy
import csv
from faker import Faker
# Define a class that represents an applicant
class Applicant:
def __init__(self):
self.name = fake.name()
self.birthday = fake.date_of_birth()
self.timestamps = []
# This method will be called each time an applicant moves to the next stage
# of the recruitment funnel
def update_timestamp(self, env, process_name):
self.timestamps.append((env.now, process_name))
# Define a function that simulates the processing of applicants through the
# recruitment funnel
def process_applicants(env, applicants):
# Loop through each applicant in the list
for applicant in applicants:
# Simulate receiving the applicant's application
yield env.timeout(1)
applicant.update_timestamp(env, "Received")
# Simulate reviewing the applicant's resume
yield env.timeout(1)
applicant.update_timestamp(env, "Resume Review")
# Simulate conducting a telephone interview with the applicant
yield env.timeout(1)
applicant.update_timestamp(env, "Telephone Interview")
# Simulate conducting an assessment of the applicant
yield env.timeout(1)
applicant.update_timestamp(env, "Assessment")
# Simulate conducting an in-person interview with the applicant
yield env.timeout(1)
applicant.update_timestamp(env, "Interview")
# Simulate making a contract offer to the applicant
yield env.timeout(1)
applicant.update_timestamp(env, "Contract Offer")
# Simulate accepting the contract offer from the applicant
yield env.timeout(1)
applicant.update_timestamp(env, "Acceptance")
# Create a simpy environment
env = simpy.Environment()
# Create a list of applicants
applicants = []
# Create a fake object to generate random names and birthdays
fake = Faker()
# Create 900 applicants with random names and birthdays
for i in range(900):
applicants.append(Applicant())
# Simulate processing the applicants through the recruitment funnel
env.process(process_applicants(env, applicants))
env.run()
# Save the applicants' data to a CSV file
with open("applicants.csv", "w") as csvfile:
writer = csv.writer(csvfile)
# Write the header row
writer.writerow(["Name", "Birthday"] + [
"Received", "Resume Review", "Telephone Interview", "Assessment",
"Interview", "Contract Offer
continue the code from line with env = simpy.Environment()
Sure, here is the updated code that continues from the env = simpy.Environment()
line:
Copy code# Create a list of applicants
applicants = []
# Create a fake object to generate random names and birthdays
fake = Faker()
# Create 900 applicants with random names and birthdays
for i in range(900):
applicants.append(Applicant())
# Simulate processing the applicants through the recruitment funnel
env.process(process_applicants(env, applicants))
env.run()
# Save the applicants' data to a CSV file
with open("applicants.csv", "w") as csvfile:
writer = csv.writer(csvfile)
# Write the header row
writer.writerow(["Name", "Birthday"] + [
"Received", "Resume Review", "Telephone Interview", "Assessment",
"Interview", "Contract Offer", "Acceptance"
])
# Write the data for each applicant
for applicant in applicants:
# Create a list of the timestamps for each stage of the recruitment funnel
timestamps = [None] * 7
for timestamp, process_name in applicant.timestamps:
if process_name == "Received":
timestamps[0] = timestamp
elif process_name == "Resume Review":
timestamps[1] = timestamp
elif process_name == "Telephone Interview":
timestamps[2] = timestamp
elif process_name == "Assessment":
timestamps[3] = timestamp
elif process_name == "Interview":
timestamps[4] = timestamp
elif process_name == "Contract Offer":
timestamps[5] = timestamp
elif process_name == "Acceptance":
timestamps[6] = timestamp
# Write the data for this applicant to the CSV file
writer.writerow([applicant.name, applicant.birthday] + timestamps)
In this updated code, the process_applicants function simulates the processing
of applicants through the recruitment funnel, and records the timestamps for
each applicant at each stage of the funnel. Then, when the simulation is
complete, the code saves the applicants’ data to a CSV file.
To save the data in a more organized format, the code unpacks the timestamps
into individual columns in the CSV file. It creates a list of the timestamps for
each stage of the recruitment funnel, and fills in the appropriate values for
each applicant. Then, it writes the data for each applicant to the CSV file,
including the name, birthday, and timestamps.
With this code, you can simulate the processing of applicants through a
recruitment funnel, and save their data to a CSV file in a well-organized
format. You can then use this data to analyze the recruitment process and
identify areas for improvement.
Can you create a pdf of or hyperlink to this conversation so that I can share it
with others?
Unfortunately, I am not able to create a PDF or hyperlink of this conversation.
I am a text-based AI assistant and do not have the ability to create or share
PDFs or hyperlinks. However, you can easily copy and paste the conversation into
a document or email to share with others.
SHARE THIS:
* Share
*
*
* WhatsApp
*
LIKE THIS:
Like Loading...
* Paul van der Laken
* 6 December 2022
* AI
* chatgpt
* llm
* openai
* python
* simpy
WORDLE WITH NLP FOR DATA SCIENTISTS
I have played my fair share of Wordle.
I’m not necessarily good at it, but most days I get to solve the puzzle.
The experience is completely different with Semantle — a Wordle-inspired puzzle
in which you also need to guess the word of the day.
Unlike in Wordle, Semantle gives you unlimited guesses though. And, boy, you
will need many!
Like Wordle, Semantle gives you hints as to how close your guesses were to the
secret word of the day.
However, where Wordle shows you how good your guesses were in terms of the
letters used, Semantle evaluates the semantic similarity of your guesses to the
secret word. For the 1000 most similar words to the secret word, it will show
you its closeness like in the picture above.
This semantic similarity comes from the domain of Natural Language Processing —
NLP — and this basically reflects how often words are used in similar contexts
in natural language.
For instance, the words “love” and “hate” may seem like opposites, but they will
often score similarly in grammatical sentences. According to the semantle FAQ
the actual opposite of “love” is probably something like “Arizona Diamondbacks”,
or “carburetor”.
Another example is last day’s solution (15 March 2022), when the secret word was
circle. The ten closest words you could have guessed include circles and
semicircle, but more distinctive words such as corner and clockwise.
Further downfield you could have guessed relatively close words like saucer,
dot, parabola, but I would not have expected words like outwaited, weaved, and
zipped.
The creator of Semantle scored the semantic similarity for almost all words used
in the English language, by training a so-called word2vec model based on a very
large dataset of news articles (GoogleNews-vectors-negative300.bin from late
2021).
Now, every day, one word is randomly selected as the secret word, and you can
try to guess which one it is. I usually give up after 300 to 400 guesses, but my
record was 76 guesses for uncovering the secret word world.
Try it out yourself: https://semantle.novalis.org/
And do share your epic wins and fails!
SHARE THIS:
* Share
*
*
* WhatsApp
*
LIKE THIS:
Like Loading...
* Paul van der Laken
* 16 March 202216 March 2022
* datascience
* game
* language
* news
* NLP
* semantle
* textmining
* wordle
BEST CHARTS FOR INCOME & PROFIT & LOSS STATEMENTS
A few months back I wrote about how Rackspace confuses their shareholders using
bad data visualization in their quarterly reports.
Mort Goldman — one of my dear readers — pointed me to this great tutorial by
Kamil Franek where he shows 7 ways to visualize income and profit and loss
statements. Please visit Kamil’s blog for the details, I just copied the visuals
here to share with you.
Maybe we should forward them to Rackspace as well
Kamil uses Google/Alphabet’s 2018 financial reports as data for his examples.
Here are two Sankey diagrams, with different levels of detail. Kamil argues they
work best for the big picture overview.
I dislike how most text 90 degrees rotated, forcing me to tilt my head in order
to read it.
An alternative Kamil proposes is the well-known Waterfall chart. Kamil dedicated
a whole blog post to creating good waterfalls.
One of my favorite visualization of the blog were these two combined bar charts.
One showing the whole bars stacked, the other showing them seperately. The
stacked one allows you to discern the bigger trend. The small ones allow for
within category comparison.
Love it!
Not so much a fan of the next stacked area chart though. In my opinion, a lot of
ink for very little information displayed.
The colors in this next one are lovely though:
The next scatter plot/bubble plot was one that I had not expected.
I love how this unorthodox visualization really add insights, showing how
different cost categories have developed over time.
There are some things I would tweak to make the graph more visually appealing
though. Particularly the benchmark line is too rough in my opinion.
Very often, you don’t need a specialized graph, but a well-formatted table might
be much more effective.
Kamil shows two great examples. The first one with an integrated bar
chart/sparkline, the second one relying strongly on color cues. I prefer the
second one, as it better shows the hierarchy in the categories with the
highlighted rows.
Kamil takes it a step further in the next table, but I think they become less
and less insightful as more information is included:
Kamil’s final recommendation is this key metrics dashboard. Though I like the
general idea, I am not sure whether this one works for me. Particularly the line
graphs on the right don’t provide much insight. I don’t know whether the last
but one dot is 20% or 5% or 50% or 0%. The lack of reference points allows it to
be any of these values.
If you haven’t yet clicked through, definitely check out Kamil’s original post.
There he shares his perspective on the advantages and disadvantages of each of
these visualization types, and where they work best in his experience.
Also check out Kamil’s earlier post on How to Visually Redesign Your Income
Statement (P&L).
SHARE THIS:
* Share
*
*
* WhatsApp
*
LIKE THIS:
Like Loading...
* Paul van der Laken
* 30 November 20211 November 2021
* best practices
* finance
* financials
* franek
* income
* kamil
* pnl
* statement
* visualization
PRACTICE YOUR DATA SCIENCE SKILLS ON REAL-LIFE DATA
Maven Analytics now provides open access to their datasets through what they
call their “DATA PLAYGROUND“!
They offer 21 datasets including a range of different data (time series,
geospatial, user preferences) on a variety of topics like business, sports,
wine, financial stocks, transportation and whatnot.
This is a great starting point if you want to practice your data science,
machine learning and analysis skills on real life data!
Maven Analytics provides e-learnings in analysis and programming software. To
provide a practical learning experience, their courses are often accompanied by
real-life datasets for students to analyze.
SHARE THIS:
* Share
*
*
* WhatsApp
*
LIKE THIS:
Like Loading...
* Paul van der Laken
* 30 November 202128 October 2021
* analytics
* data
* datascience
* datasets
* free
* machinelearning
* maven
* openaccess
* realdata
* reallife
VOX: ARE WE AUTOMATING RACISM?
In Glad You Asked, Vox dives deep into timely questions around the impact of
systemic racism on our communities and in our daily lives.
In this video, they look into the role of tech in societal discrimination.
People assume that tech and data are neutral, and we have turned to tech as a
way to replace biased human decision-making. But as data-driven systems become a
bigger and bigger part of our lives, we see more and more cases where they fail.
And, more importantly, that they don’t fail on everyone equally.
Why do we think tech is neutral? How do algorithms become biased? And how can we
fix these algorithms before they cause harm? Find out in this mini-doc:
SHARE THIS:
* Share
*
*
* WhatsApp
*
LIKE THIS:
Like Loading...
* Paul van der Laken
* 16 November 202112 October 2021
* automation
* bias
* data
* decisionmaking
* discrimination
* ethics
* fairness
* racism
* society
* tech
* video
* vox
A NEW PIECE IN MY ALGORITHMIC ART COLLECTION
Those who have been following me for some time now will know that I am a big fan
of generative art: art created through computers, mathematics, and algorithms.
Several years back, my now wife bought me my first piece for my promotion, by
Marcus Volz.
And several years after that, I made my own attempt at a second generative art
piece, again inspired by the work of Marcus on what he dubbed Metropolis.
Now, our living room got a third addition in terms of the generative art, this
time by Nicholas Rougeux.
Nicholas I bumped into on twitter, triggered by his collection of “Lunar
Landscapes” (my own interpretation).
Nicholas was hesistant to sell me a piece and insisted that this series was not
finished yet.
Yet, I already found it wonderful and lovely to look at and after begging
Nicholas to sell us one of his early pieces, I sent it over to ixxi to have it
printed and hanged it on our wall above our dinner table.
If you’re interested in Nicholas’ work, have a look at c82.net
SHARE THIS:
* Share
*
*
* WhatsApp
*
LIKE THIS:
Like Loading...
* Paul van der Laken
* 2 November 202114 October 2021
* algorithm
* art
* design
* generative
* mathematics
* personal
POSTS NAVIGATION
Older posts
SEARCH ARCHIVES
Search for:
MOST READ
READ MORE
AI algorithm application automation data datascience dataviz deeplearning design
ggplot2 GIF hr javascript learning machinelearning maps neuralnetwork
programming python r research science statistics text textmining tidyverse
Tutorial video visualization youtube
STATISTICS
* 729,079 readers
RECEIVE UPDATES
Receive notifications of new content.
Email Address:
Follow
Join 1,411 other subscribers
BROWSE ARCHIVES
Browse Archives Select Category application (57) automation (44) best
practices (59) conference (13) cyber security (2) datasets (6) deep
learning (37) design (21) entertainment (57) ethics (8) experiment (16)
finance (2) gadget (1) hr (27) java (9) javascript (29) learning (95)
machine learning (85) news (12) programming (37) python (59) r (134)
reading (17) reinforcement learning (4) report (11) research (42)
statistics (75) text mining (27) tools (33) visualization (139)
* Blog
* About
* Contact
Blog at WordPress.com.
paulvanderlaken.com
Blog at WordPress.com.
* Follow Following
* paulvanderlaken.com
Join 379 other followers
Sign me up
* Already have a WordPress.com account? Log in now.
* Privacy
* * paulvanderlaken.com
* Customize
* Follow Following
* Sign up
* Log in
* Report this content
* View site in Reader
* Manage subscriptions
* Collapse this bar
Loading Comments...
Write a Comment...
Email (Required) Name (Required) Website
%d