SoFunction
Updated on 2025-03-03

Detailed explanation of examples of using Python for user portrait construction

User portrait, also known as user profile or customer portrait, is a virtual user model created by collecting and analyzing multi-dimensional information such as user behavior, preferences, and needs. It is an abstraction and generalization of the target user group, aiming to help companies better understand their customers in order to provide them with more personalized and accurate products and services.

This article will introduce in detail how to use Python to build user portraits, and combine them with actual application scenarios to give the tasks and system framework for each stage.

User portrait

User portraits usually contain the following aspects:

  • Basic attributes: including basic information such as user's age, gender, occupation, education level, geographical location, etc.
  • Psychological characteristics: characteristics involving the user's personality, life attitude, values ​​and other psychological aspects.
  • Behavioral characteristics: User behavioral habits on the Internet, such as browsing web pages, using applications, shopping, social interaction, etc.
  • Consumption habits: information related to consumption such as user's purchasing behavior, purchasing frequency, preference for products, consumption capacity, etc.
  • Needs and preferences: user's specific needs, interests, brand preferences, etc.

The construction of user portraits usually involves the following steps:

  • Data collection: Collect user data from multiple channels, including online behavioral data, transaction records, questionnaires, social media, etc.
  • Data preprocessing: Clean and organize the collected data, process missing values ​​and outliers, and convert unstructured data into structured data.
  • Feature Engineering: Extract useful features from raw data and create new metrics that represent user attributes and behavior.
  • User grouping: Use clustering analysis and other methods to divide users into different groups, each group has similar characteristics and behaviors.
  • Portrait construction: Create a detailed user portrait for each group based on the grouping results, including descriptions of key attributes and behavior patterns.
  • Application and optimization: Apply user portraits to business areas such as marketing, product design, customer service, etc., and continuously optimize and update user portraits based on actual results and feedback.

User portraits are an important tool for enterprises to understand and serve target customer groups. By collecting and analyzing user behavior data, preferences, needs and other information, enterprises can build segmented user group models, thereby achieving precise marketing and service improvements.

1. Data collection and preprocessing

Task:

Collect user behavior data

Clean data, handle missing and outliers

Convert data formats to prepare for analysis

System framework components:

Data collection module: Use Python's requests library to obtain data from a database, API or third-party platform.

Data cleaning module: Use the pandas library to preprocess data, including removing duplicate values, filling or deleting missing values, data type conversion, etc.

2. Feature Engineering

Task:

Identify key features of user portraits

Create metrics for user behavior and preferences

Perform feature selection and eliminate unimportant features

System framework components:

Feature building module: Use pandas and numpy to create features according to business needs, such as user activity, purchase frequency, etc.

Feature selection module: Use SelectKBest or Recursive Feature Elimination methods in scikit-learn for feature selection.

3. User grouping

Task:

Use grouping algorithm to divide users into different groups

Analyze the characteristics and behavioral patterns of each group

System framework components:

Grouping algorithm module: Use clustering algorithms such as KMeans or DBSCAN in scikit-learn.

Group analysis module: analyze the clustering results and extract the characteristics and behavioral patterns of each group.

4. User portrait modeling

Task:

Build prediction models to predict user behavior and preferences

Evaluate the performance and accuracy of the model

System framework components:

Modeling module: Use the classification or regression algorithm in scikit-learn to build a user behavior prediction model.

Evaluation module: The model is evaluated and optimized using cross-validation, ROC curve and other methods.

5. Application and Optimization

Task:

Apply user portraits to actual business scenarios

Continuously optimize user portraits based on feedback and business changes

System framework components:

Application module: Integrate user portraits into business processes such as recommendation systems and marketing activities.

Optimization module: Continuously adjust and improve user profile models based on business feedback and new data.

Practical application scenarios

Suppose we are an e-commerce company and hope to improve user shopping experience and satisfaction through user portraits. We can follow the steps below:

Data collection and preprocessing: Collect user browsing history, purchase history, registration information and other data from the website backend and database, and clean and format it.

Characteristic engineering: According to business needs, build characteristics such as user activity, purchase frequency, average consumption amount, etc., and filter out the characteristics that have the most impact on user behavior prediction.

User grouping: Use clustering algorithm to divide users into several groups, such as high-value users, active users, potentially lost users, etc.

User portrait modeling: For each user group, predict predictive models and predict changes in their purchasing behavior and preferences.

Application and optimization: Apply user portraits to personalized recommendations, targeted marketing, customer service and other links, and continuously optimize them based on user feedback and business results.

Through the above steps, we can build a complete user profile system to help enterprises better understand customers and achieve precise marketing and service improvements.

Code Example

Here is a more specific Python code snippet for example building user portraits. In this example, we will use the KMeans clustering algorithm to group users and create some basic user characteristics.

# Import the necessary librariesimport pandas as pd
from  import KMeans
from  import StandardScaler
from  import silhouette_score

# Suppose we have a DataFrame 'df' that contains user behavior data# df = pd.read_csv('user_data.csv') # Read data
# Here we create a sample DataFramedata = {
    'UserID': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
    'Age': [25, 30, 22, 35, 40, 23, 29, 31, 39, 24],
    'Gender': ['F', 'M', 'F', 'M', 'F', 'M', 'F', 'M', 'F', 'M'],
    'Total_Spent': [50, 200, 150, 450, 120, 250, 130, 320, 180, 300],
    'Avg_Daily_Visits': [1.2, 1.5, 0.8, 2.0, 1.0, 2.2, 1.0, 1.8, 1.5, 2.0],
    'Product_Interests': ['Tech, Fashion', 'Books, Tech', 'Fashion, Home', 'Books, Health', 'Tech, Sports', 'Books', 'Fashion, Sports', 'Home, Health', 'Tech', 'Books, Fashion']
}

df = (data)

# Data preprocessing# Convert Gender and Product_Interests to numerical datadf['Gender'] = df['Gender'].map({'F': 1, 'M': 0})

# Split Product_Interests into multiple columnsinterests = df['Product_Interests'].(',', expand=True)
df = ('Product_Interests', axis=1)
df = ([df, interests], axis=1)

# Feature Engineering# Create new features such as user valuedf['User_Value'] = df['Total_Spent'] * df['Avg_Daily_Visits']

# Standardized Featuresscaler = StandardScaler()
df_scaled = scaler.fit_transform(df[['Age', 'Total_Spent', 'Avg_Daily_Visits', 'User_Value']])

# User grouping# Use KMeans algorithm to group userskmeans = KMeans(n_clusters=3, random_state=42)
df['Cluster'] = kmeans.fit_predict(df_scaled)

# Calculate the contour coefficient and evaluate the grouping effectsil_score = silhouette_score(df_scaled, df['Cluster'])
print(f"Silhouette Score: {sil_score}")

# Output information and grouping results of the first few usersprint(df[['UserID', 'Gender', 'Cluster']].head())

In this code snippet, we first create a DataFrame containing user data. We then performed some basic data preprocessing, including converting gender and product interests into numerical data, and created a new feature User_Value to represent user value.

Next, we standardize the features and use the KMeans algorithm to group users. We also calculated the profile coefficients to evaluate the effect of grouping and output the information and grouping results of the first few users.

Note that this example is to demonstrate the basic process of using Python for user portrait building. In practical applications, you may need to deal with more complex data sets, build more complex features, use more advanced clustering and prediction models, and perform detailed model evaluation and optimization. In addition, for category features such as product interests, more complex encoding methods such as One-Hot Encoding or other text vectorization techniques may be required.

This is the end of this article about the detailed explanation of the examples of using Python for user portrait construction. For more related content on Python user portrait construction, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!