案例：国产电视剧评分预测

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns
import random
from sklearn.preprocessing import LabelEncoder
from sklearn.linear_model import LinearRegression
from sklearn.metrics import recall_score
from sklearn.metrics import accuracy_score
from sklearn.metrics import mean_squared_error
from sklearn.metrics import mean_absolute_error
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from plotly import tools
import plotly.express as px
from plotly.offline import init_notebook_mode, iplot, plot
import plotly.figure_factory as ff
import plotly.graph_objs as go
import ast

df = pd.read_csv("tv_rating.csv")
df

df.isna().sum()

title     0
rating    0
stars     0
dtype: int64

df.rating = df.rating.apply(lambda x: x.replace("分", ""))
df.rating = pd.to_numeric(df.rating)
df

def handleStars(stars):
    stars = stars.replace("主演", "")
    result_arr = []
    base_arr = stars.split(",")
    return base_arr
df.stars = df.stars.apply(handleStars)
df

df["star_count"] = df.stars.apply(len)
df

df[df.star_count==1].stars

df[df.star_count==1][100:150]

def handleStarStep2(stars):
    spliters = [' ', '/','，','、']
    result_arr = []
    for item in stars:
        for spliter in spliters:
            temp_arr = item.split(spliter)
            for sub_item in temp_arr:
                temp_item = sub_item.strip()
                if temp_item not in result_arr:
                    result_arr.append(temp_item)
    return result_arr
df.stars = df.stars.apply(handleStarStep2)
df

df["star_count"] = df.stars.apply(len)
df[df.star_count ==1]

df.rating.hist()

df["title_len"] = df.title.apply(len)
df.title_len.hist()

df.star_count.hist()

df["title_len"] = df.title.apply(len)
px.scatter(df, x="title_len", y = "rating")

px.scatter(df, x="star_count", y="rating")

df_train,df_test = train_test_split(df, test_size=0.2, random_state=42)
df_test

random_result = np.random.uniform(0.0,5.0, 720)
mean_squared_error(random_result, df_test["rating"])

4.260423686305926

from xgboost import XGBRegressor
features =  ["title_len","star_count"]
target = "rating"
xgb = XGBRegressor(n_estimators = 2000 , random_state = 0 , max_depth = 27)
df_train_features = df_train[features]
df_train_target = df_train[target]
xgb.fit(df_train_features, df_train_target)
df_test_feat = df_test[features]
df_test_result = xgb.predict(df_test_feat)
mean_squared_error(df_test_result, df_test[target])

2.2631812293604723

all_stars={}
all_top_stars = {}
i = 0
for item in df.stars.values:
    rating = df.loc[i, "rating"]
    for sub_item in item:
        if sub_item in all_stars:
            all_stars[sub_item] = all_stars[sub_item] + 1
        else:
            all_stars[sub_item] = 1
        # 该演员参演的电视剧评分大于等于 4，则记为优秀演员
        if rating >= 4:
            if sub_item in all_top_stars:
                all_top_stars[sub_item] = all_top_stars[sub_item] + 1
            else:
                all_top_stars[sub_item] = 1
    i = i+1
print("普通演员个数：", len(all_stars))
print("优秀演员个数：",len(all_top_stars))

普通演员个数： 8808
优秀演员个数： 1237

def get_sr_stars_count(c,l):
    result = 0
    for item in l:
        if all_stars[item] > c:
            result = result+1
    return result
def get_top_stars_count(l):
    result = 0
    for item in l:
        if item in all_top_stars:
            result = result + 1
    return result
def get_top_stars_movie_count(l):
    result = 0
    for item in l:
        if item in all_top_stars:
            result = result + all_top_stars[item]
    return result
df["sr_stars_count"] = df.stars.apply(lambda x:get_sr_stars_count(3,x))
df["top_stars_count"] = df.stars.apply(get_top_stars_count)
df["top_stars_movie_count"] = df.stars.apply(get_top_stars_movie_count)
df

from xgboost import XGBRegressor
features =  ["top_stars_count", "top_stars_movie_count","sr_stars_count"]
target = "rating"
df_train,df_test = train_test_split(df, test_size=0.2, random_state=42)
xgb = XGBRegressor(n_estimators = 2000 , random_state = 0 , max_depth = 27)
df_train_features = df_train[features]
df_train_target = df_train[target]
xgb.fit(df_train_features, df_train_target)
df_test_feat = df_test[features]
df_test_result = xgb.predict(df_test_feat)
mean_squared_error(df_test_result, df_test[target])

1.8756039712703974