OneHotEncoder Encodes categorical integer features as a one-hot numeric array. Its Transform method returns a sparse matrix if sparse=True, otherwise it returns a 2-d array.

You can't cast a 2-d array (or sparse matrix) into a Pandas Series. You must create a Pandas Serie (a column in a Pandas dataFrame) for each category.

I would recommend pandas.get_dummies instead:

data = pd.get_dummies(data,prefix=['Profession'], columns = ['Profession'], drop_first=True)

EDIT:

Using Sklearn OneHotEncoder:

transformed = jobs_encoder.transform(data['Profession'].to_numpy().reshape(-1, 1))
#Create a Pandas DataFrame of the hot encoded column
ohe_df = pd.DataFrame(transformed, columns=jobs_encoder.get_feature_names())
#concat with original data
data = pd.concat([data, ohe_df], axis=1).drop(['Profession'], axis=1)

Other Options: If you are doing hyperparameter tuning with GridSearch it's recommanded to use ColumnTransformer and FeatureUnion with Pipeline or directly make_column_transformer

This library provides several categorical encoders which make sklearn / numpy play nicely with pandas https://github.com/wdm0006/categorical_encoding

However, they do not yet support "handle unknown category"

for now I will use

myEncoder = OneHotEncoder(sparse=False, handle_unknown='ignore')
myEncoder.fit(df[columnsToEncode])

pd.concat([df.drop(columnsToEncode, 1),
          pd.DataFrame(myEncoder.transform(df[columnsToEncode]))], axis=1).reindex()

As this supports unknown datasets. For now, I will stick with half-pandas half-numpy because of the nice pandas labels. for the numeric columns.

I see you are already using Pandas, so why not using its get_dummies function?

import pandas as pd
df = pd.DataFrame([['rick','young'],['phil','old'],['john','teenager']],columns=['name','age-group'])

result

   name age-group
0  rick     young
1  phil       old
2  john  teenager

now you encode with get_dummies

pd.get_dummies(df)

result

name_john  name_phil  name_rick  age-group_old  age-group_teenager  \
0          0          0          1              0                   0   
1          0          1          0              1                   0   
2          1          0          0              0                   1   

   age-group_young  
0                1  
1                0  
2                0

And you can actually use the new Pandas DataFrame in your Sklearn's DecisionTreeClassifier.

IIUC, use get_feature_names_out():

import pandas as pd
from sklearn.preprocessing import OneHotEncoder

df = pd.DataFrame({'A': [0, 1, 2], 'B': [3, 1, 0],
                   'C': [0, 2, 2], 'D': [0, 1, 1]})

ohe = OneHotEncoder()
data = ohe.fit_transform(df)
df1 = pd.DataFrame(data.toarray(), columns=ohe.get_feature_names_out(), dtype=int)

Output:

>>> df
   A  B  C  D
0  0  3  0  0
1  1  1  2  1
2  2  0  2  1


>>> df1
   A_0  A_1  A_2  B_0  B_1  B_3  C_0  C_2  D_0  D_1
0    1    0    0    0    0    1    1    0    1    0
1    0    1    0    0    1    0    0    1    0    1
2    0    0    1    1    0    0    0    1    0    1

>>> pd.Series(ohe.get_feature_names_out()).str.rsplit('_', 1).str[0]
0    A
1    A
2    A
3    B
4    B
5    B
6    C
7    C
8    D
9    D
dtype: object

Scikit-learn provides an encoder sklearn.preprocessing.LabelBinarizer.

For encoding training data you can use fit_transform which will discover the category labels and create appropriate dummy variables.

label_binarizer = sklearn.preprocessing.LabelBinarizer()
training_mat = label_binarizer.fit_transform(df.Label)

For the test data you can use the same set of categories using transform.

test_mat = label_binarizer.transform(test_df.Label)

(My basic answer, post a more informed one and I'll accept it.)

Examples from this article show that the OneHotEncoder will encode for every unique value in a column.

You can check what's being encoded by using the OneHotEncoder().categories_ attribute. This attribute will give you a series of arrays that include all the unique values of each column that have been encoded for. If you feed numerical values into the OneHotEncoder you'll notice that these arrays contain every unique numerical value as a category.

To avoid this, you should pre-select your categorical columns and feed those to the OneHotEncoder. See the following SciKit-Learn Tutorial, and the reference for ColumnTransformer to see how this can be included in a pipeline.

You can't pass a feature containing a merged list directly to the model. You should one-hot encode into separate columns first:

• If you just want something quick and easy, get_dummies is fine for development, but the following approaches are generally preferred by most sources I've read.
• If you want to encode your input data, use OneHotEncoder (OHE) to encode one or more columns, then merge with your other features. OHE gives good control over output format, stores intermediate data and has error handling. Good for production.
• If you need to encode a single column, typically but not limited to labels, use LabelBinarizer to one-hot encode a column with a single value, or use MultiLabelBinarizer to one-hot encode a column with multiple values.

Once you have your one-hot encoded data/labels, you don't need to "tell" the model that certain features are one-hot. You just train the model on the data set using clf.fit(X_train, y_train) and make predictions using clf.predict(X_test).

OHE example

from sklearn.preprocessing import OneHotEncoder
import pandas as pd

X = [['Male', 1], ['Female', 3], ['Female', 2]]
ohe = OneHotEncoder(handle_unknown='ignore')
X_enc = ohe.fit_transform(X).toarray()

# Convert to dataframe if you need to merge this with other features:
df = pd.DataFrame(X_enc, columns=ohe.get_feature_names())

MLB example

from sklearn.preprocessing import MultiLabelBinarizer
import pandas as pd

df = pd.DataFrame({
   'style': ['Folk', 'Rock', 'Classical'],
   'instruments': [['guitar', 'vocals'], ['guitar', 'bass', 'drums', 'vocals'], ['piano']]
})

mlb = MultiLabelBinarizer()
encoded = mlb.fit_transform(df['instruments'])
encoded_df = pd.DataFrame(encoded, columns=mlb.classes_, index=df['instruments'].index)

# Drop old column and merge new encoded columns
df = df.drop('instruments', axis=1)
df = pd.concat([df, encoded_df], axis=1, sort=False)