{"id":1380,"date":"2026-06-23T16:30:00","date_gmt":"2026-06-23T16:30:00","guid":{"rendered":"https:\/\/futurenews24.com\/index.php\/2026\/06\/23\/i-spent-an-hour-on-a-data-preprocessing-task-before-asking-gemini\/"},"modified":"2026-06-23T16:59:27","modified_gmt":"2026-06-23T16:59:27","slug":"i-spent-an-hour-on-a-data-preprocessing-task-before-asking-gemini","status":"publish","type":"post","link":"https:\/\/futurenews24.com\/index.php\/2026\/06\/23\/i-spent-an-hour-on-a-data-preprocessing-task-before-asking-gemini\/","title":{"rendered":"I Spent an Hour on a Information Preprocessing Job Earlier than Asking Gemini"},"content":{"rendered":"
\n<\/p>\n
\n
a big period of time on knowledge preparation for downstream duties. Whether or not it entails knowledge cleansing, dealing with lacking values, function engineering, knowledge preprocessing, or publish processing, this section requires a whole lot of time.<\/p>\n
So, I used to be engaged on this post-processing activity the place I wanted to create a brand new column in a Pandas DataFrame by extracting values from an current column, based mostly on the information from two different columns. <\/p>\n
I might have immediately requested an LLM to write down the code (which I normally do) however this time I wished to do it myself. It was early within the morning and I had a contemporary thoughts so I used to be within the temper to deal with some complicated knowledge operations.<\/p>\n
Here’s what I needed to do. I had a DataFrame with predicted_categories, pred_category_id, and text_predicted_probs columns.<\/p>\n
The values within the predicted_categories column are lists of 5 classes in \u201ccategory_id\u201d \u2013 \u201ccategory_description\u201d format. <\/p>\n
The text_predicted_probs column has the anticipated possibilities of those 5 classes so as. <\/p>\n
[0.943, 0.018, 0.008, 0.006, 0.004]<\/p>\n
Therefore, the primary worth within the text_predicted_probs is the chance of the primary class within the predicted_categories, and so forth.<\/p>\n
The pred_category_id column reveals the anticipated class id from one other mannequin . What I want is the anticipated chance of the class within the pred_category_id column.<\/p>\n
I must get the order of the pred_category_id within the predicted_categories column after which take its worth from the test_predicted_probs column.<\/p>\n
The drawing beneath demonstrates what I wish to obtain:<\/p>\n<\/figure>\n
On this drawing, I wish to get the chance of class 13003106, which is the second merchandise within the checklist and its corresponding chance worth is 0.018.<\/p>\n
If we requested Gemini, or one other superior mannequin, we\u2019ll in all probability get the reply in seconds. However, I wished to do it alone first after which ask Gemini.<\/p>\n
Let\u2019s begin with studying the dataset right into a Pandas DataFrame.<\/p>\n
It\u2019s a listing however saved as a string so we first convert it to a listing object utilizing the literal_eval operate within the built-in ast module of Python:<\/p>\n
To extract the class ids, we are able to break up every string on this checklist on the \u201c-\u201d character after which choose the primary half after splitting. Since we’ve got a listing with 5 classes, we should always do that operation in a listing comprehension as follows:<\/p>\n
[category.split(“-“)[0].strip() \nfor class in ast.literal_eval(outcomes.loc[0, “predicted_categories”])] \n# output: \n[‘80814001’, ‘13003106’, ‘80805004’, ‘13003144’, ‘13003195’]<\/p>\n
We\u2019ve completed it for a single worth (i.e. one row). With a purpose to do the identical operation to all the predicted_categories column, we are able to use a listing comprehension. Will probably be a listing comprehension inside one other checklist comprehension (i.e. nested checklist comprehension):<\/p>\n
outcomes.loc[:, “predicted_category_ids”] = [ \n [category.split(“-“)[0].strip() for class in ast.literal_eval(predicted_categories)] \n for predicted_categories in outcomes[“predicted_categories”] \n]<\/p>\n
We now have class ids extracted from the predicted_categories column:<\/p>\n<\/figure>\n
The subsequent step is to examine the order of the classes within the predicted class id lists. We’ll then use this order to extract the anticipated chance of the class.<\/p>\n
Python checklist object has an index methodology, which returns the index (i.e. order) of the merchandise within the checklist.<\/p>\n
As soon as I discover the index of a predicted class id, I can use it to get the chance of this class id from the text_predicted_probs column:<\/p>\n<\/figure>\n
What we have to do:<\/p>\n
Get the index of pred_category_id within the predicted_category_ids<\/p>\n
Use this index to extract the related worth from text_predicted_probs<\/p>\n
These steps could be completed in a single operation by zipping these three columns. Let\u2019s take a look at it on the primary row:<\/p>\n
for i, j, ok in zip(outcomes[“pred_category_id”][:1], outcomes[“predicted_category_ids”][:1], outcomes[“text_predicted_probs”][:1]): \n print(j.index(str(i))) # get the index of pred_category_id in predicted_category_ids \n print(ast.literal_eval(ok)[j.index(str(i))]) # get the worth at this index in text_predicted_probs<\/p>\n
# output: \n0 \n0.943<\/p>\n
We are able to affirm the output within the screenshot above. The pred_category_id is 80814001, which is the primary merchandise (i.e. index = 0) within the predicted_category_ids and the primary chance worth is 0.943.<\/p>\n
The lists within the text_predicted_probs column are saved as string as effectively so we apply the literal_eval operate to transform them to a listing object.<\/p>\n
We are able to do that operation on all the DataFrame utilizing a listing comprehension as observe:<\/p>\n
outcomes.loc[:, “pred_category_prob”] = [ \n float(ast.literal_eval(k)[j.index(str(i))]) if str(i) in j else 0 \n for i, j, ok in zip(outcomes[“pred_category_id”], outcomes[“predicted_category_ids”], outcomes[“text_predicted_probs”]) \n]<\/p>\n
We mainly transformed the for loop within the earlier code block to a listing comprehension. I\u2019ve solely added a examine \u201cif str(i) in j else 0\u201d as a result of there are some rows with a pred_category_id that doesn’t exist in predicted_category_ids. In such circumstances, we set the chance worth to 0.<\/p>\n
The duty is now accomplished as we are able to see beneath:<\/p>\n<\/figure>\n
How did Gemini do that?<\/h2>\n
After working about an hour (together with breaks) I accomplished the duty. Then, I wished to ask Gemini to see how it will deal with the identical activity.<\/p>\n
I wrote a immediate explaining my aim and included a small pattern of the information.<\/p>\n
Here’s what Gemini produced on its first try:<\/p>\n
# 2. Outline a operate to extract the chance matching the class ID \ndef get_matching_prob(row): \n # Convert ID to string for matching \n target_id_str = str(row[‘pred_category_id’])<\/p>\n
# Iterate by the classes to seek out the matching index \n for index, class in enumerate(row[‘predicted_categories’]): \n if class.startswith(target_id_str): \n # Return the corresponding chance from the identical index \n return row[‘text_predicted_probs’][index]<\/p>\n
# Return None (or 0) if no match is discovered to stop the code from crashing \n return None<\/p>\n
# 3. Create the brand new column \ndf[‘pred_category_prob’] = df.apply(get_matching_prob, axis=1)<\/p>\n
# Show the end result \nprint(df[[‘pred_category_id’, ‘pred_category_prob’]])<\/p>\n
It first created a pattern DataFrame utilizing the information I supplied within the immediate. Then, it wrote a operate that does precisely what I defined.<\/p>\n
It took me about an hour to write down the code myself. Gemini accomplished the very same activity in seconds based mostly on a immediate that took me just a few minutes to write down. <\/p>\n
Nonetheless, there’s a minor subject in Gemini\u2019s code. It makes use of the apply operate, which isn’t vectorized. In case of working with massive datasets, utilizing the apply operate (mainly a for loop) can improve the run time. <\/p>\n
However the resolution is easy. I requested Gemini to write down a vectorized model of it and here’s what I acquired:<\/p>\n
# 1. Explode each checklist columns concurrently to keep up alignment between class and chance \ndf_exploded = df.explode([‘predicted_categories’, ‘text_predicted_probs’])<\/p>\n
# 2. Extract the numeric ID from the class string utilizing vectorized regex \ndf_exploded[‘extracted_id’] = df_exploded[‘predicted_categories’].str.extract(r’^(d+)’).astype(float)<\/p>\n
# 3. Filter for rows the place the extracted ID matches the goal ‘pred_category_id’ \nmatched = df_exploded[df_exploded[‘extracted_id’] == df_exploded[‘pred_category_id’]]<\/p>\n
# 4. Dedup the index (security internet in case an ID seems twice inside the identical checklist) \nmatched = matched[~matched.index.duplicated(keep=’first’)]<\/p>\n
# 5. Map the extracted chance column again to the unique DataFrame utilizing the index \ndf[‘pred_category_prob’] = matched[‘text_predicted_probs’]<\/p>\n
df<\/p>\n
The second resolution was completely advantageous and seemed less complicated than the code I wrote.<\/p>\n
So, I spent about an hour on a activity that an LLM might have accomplished in lower than 5 minutes. Nonetheless, if I didn\u2019t know the way Pandas labored, I’d have accepted the primary resolution, which was not the optimum one. It’s a good instance of how LLMs can improve productiveness, however provided that you really know what you\u2019re doing.<\/p>\n<\/div>\n
![\"\"](\"https:\/\/contributor.insightmediagroup.io\/wp-content\/uploads\/2026\/06\/image-274-1024x546.png\")
<\/figure>\n![\"\"](\"https:\/\/contributor.insightmediagroup.io\/wp-content\/uploads\/2026\/06\/image-299-1024x183.png\")
<\/figure>\n![\"\"](\"https:\/\/contributor.insightmediagroup.io\/wp-content\/uploads\/2026\/06\/image-298-1024x251.png\")
<\/figure>\n![\"\"](\"https:\/\/contributor.insightmediagroup.io\/wp-content\/uploads\/2026\/06\/image-300-1024x214.png\")
<\/figure>\n