观影大数据分析

王 S 聪想要在海外开拓万 D 电影的市场，这次他在考虑：怎么拍商业电影才
能赚钱？毕竟一些制作成本超过 1 亿美元的大型电影也会失败。这个问题对电影
业来说比以往任何时候都更加重要。所以，他就请来了你（数据分析师）来帮
他解决问题，给出一些建议，根据数据分析一下商业电影的成功是否存在统一公
式？以帮助他更好地进行决策。
解决的终极问题是：电影票房的影响因素有哪些？
接下来我们就分不同的维度分析：
• 观众喜欢什么电影类型？有什么主题关键词？
• 电影风格随时间是如何变化的？
• 电影预算高低是否影响票房？
• 高票房或者高评分的导演有哪些？
• 电影的发行时间最好选在啥时候？
• 拍原创电影好还是改编电影好？
本次使用的数据来自于 Kaggle 平台（TMDb 5000 Movie Database）。收录了
美国地区 1916-2017 年近 5000 部电影的数据，包含预算、导演、票房、电影评
分等信息。原始数据集包含 2 个文件：
• tmdb_5000_movies：电影基本信息，包含 20 个变量
• tmdb_5000_credits：演职员信息，包含 4 个变量
请使用 Python 编程，完成下列问题：
（1）使用附件中的 tmdb_5000_movies .csv 和 tmdb_5000_credits .csv 数据集，进
行数据清洗、数据挖掘、数据分析和数据可视化等，研究电影票房的影响因素有
哪些？从不同的维度分析电影，讨论并分析你的结果。
（2）附件 tmdb_1000_predict.csv 中包含 1000 部电影的基本信息，请你选择
合适的指标，进行特征提取，建立机器学习的预测模型，预测 1000 部电影的
vote_average 和 vote_count，并保存为 tmdb_1000_predicted.csv。

首先是数据清洗：在爱数科上进行

2.数据清洗
1.导入数据
2.缺失值处理
缺失记录仅 3941条，采取网上搜索，补全信息。

2.1 补全 release_date

缺失记录的电影标题为《America Is Still the Place》，日期为 2014-06-01。

2.2 补全 runtime

1. Chiamatemi Francesco - Il Papa della gente

2. To Be Frank, Sinatra at 100

缺失记录的电影 runtime 分别为94min 和81min。

3 重复值处理

运行结果：有0个不重复的 id，可以认为没有重复数据。

4 日期值处理

将release_date列转换为日期类型：（两种方式）

def changeRelease_date():
    df['release_date'] = pd.to_datetime(df['release_date'])

5 筛选数据

使用数据分析师最喜欢的一个语法：

票房、预算、受欢迎程度、评分为负数或者0的数据应该去除；

　　　　　　五个不为负数或者0筛选条件，进行筛选

评分人数过低的电影，评分不具有统计意义，筛选评分人数大于178的数据。

此时剩余___2422___条数据，包含___20___个字段。

6 json 数据转换

**说明：**genres,keywords,production_companies,production_countries,cast,crew 这6列都是json 数据，需要处理为列表进行分析。

处理方法：

json 本身为字符串类型，先转换为字典列表，再将字典列表转换为，以’,'分割的字符串

json_column = ['genres', 'keywords', 'production_companies', 'production_countries', 'cast', 'crew']
for i in json_column:
    df[i] = df[i].apply(json.loads)
def get_name(x):
    return ','.join([i['name'] for i in x])
df['cast'] = df['cast'].apply(get_name)
def get_director(x):
    for i in x:
        if i['job'] == 'Director':
            return i['name']
df['crew'] = df['crew'].apply(get_director)
for j in json_column[0:4]:
    df[j] = df[j].apply(get_name)
rename_dict = {'cast': 'actor', 'crew': 'director'}
df.rename(columns=rename_dict, inplace=True)
df.info()
print(df.head(5).genres)
print(df.head(5).keywords)
print(df.head(5).production_companies)
print(df.head(5).production_countries)
print(df.head(5).actor)
print(df.head(5).director)

7 数据备份

df_copy = df.copy()
df.reset_index().to_csv("copy.csv")

数据清洗over

5 数据分析

5.1 why

想要探索影响票房的因素，从电影市场趋势，观众喜好类型，电影导演，发行时间，评分与

关键词等维度着手，给从业者提供合适的建议。

5.2 what

5.2.1 电影类型：定义一个集合，获取所有的电影类型

genre = set()
for i in df['genres'].str.split(','): 
    genre = set().union(i,genre)    
print(genre)

注意到集合中存在多余的元素：空的单引号，所以需要去除。

5.2.1.1 电影类型数量（绘制条形图）

采用pyecharts画图

def MovieType():
    movie_genres = []
    genres = df['genres'].values.tolist()
    for genre in genres:
        genre_list = genre.split(',')
        for i in genre_list:
            movie_genres.append(i)
    movie_type = pd.DataFrame(movie_genres, index=None, columns=['type'])
    df_grp = movie_type.apply(pd.value_counts)
    diary_type = dict(zip(df_grp.index.values.tolist(), df_grp['type'].tolist()))
    d_order = sorted(diary_type.items(), key=lambda x: x[1], reverse=False)
    keys = []
    values = []
    for key, value in d_order:
        keys.append(key)
        values.append(value)
    bar = Bar(init_opts=opts.InitOpts(width="100%"))
    bar.add_xaxis(keys)
    bar.add_yaxis("电影类型数量", values)
    bar.set_series_opts(label_opts=opts.LabelOpts(is_show=True, position='right'))
    bar.reversal_axis()
    bar.set_global_opts(title_opts=opts.TitleOpts(title="电影类型数量"))
    page.add(bar)

5.2.1.2 电影类型占比（绘制饼图）

def MovieTypePie():
    movie_genres = []
    genres = df['genres'].values.tolist()
    for genre in genres:
        genre_list = genre.split(',')
        for i in genre_list:
            movie_genres.append(i)
    movie_type = pd.DataFrame(movie_genres, index=None, columns=['type'])
    df_grp = movie_type.apply(pd.value_counts)
    pie = Pie(init_opts=opts.InitOpts(width="100%", height="700px"))
    pie.add("", [list(z) for z in zip(df_grp.index.values.tolist(),
                                      df_grp['type'].tolist())])  # zip函数两个部分组合在一起list(zip(x,y))-----> [(x,y)]
    pie.set_global_opts(title_opts=opts.TitleOpts(title="电影类型占比"))  # 标题
    pie.set_series_opts(label_opts=opts.LabelOpts(formatter="{b}: {d}%"))  # 数据标签设置

    pie.render('first_bar.html')
    page.add(pie)

5.2.1.3 电影类型变化趋势（绘制折线图）

def MovieTrend():
    genre = set()
    for i in df['genres'].str.split(','):
        genre = set().union(i, genre)
    print(genre)
    genre_list = list(genre)
    genre_df = pd.DataFrame()
    for i in genre_list:
        genre_df[i] = df['genres'].str.contains(i).apply(lambda x: 1 if x else 0)
    df['release_year'] = pd.to_datetime(df.release_date, format='%Y-%m-%d', errors='coerce').dt.year
    genre_df.index = df['release_year']
    gen_year_sum = genre_df.sort_index(ascending=False).groupby('release_year').sum()
    year = []
    for i in df['release_year'].sort_values().drop_duplicates().tolist():
        year.append(str(i))
    line = Line(init_opts=opts.InitOpts(width="100%"))
    line.add_xaxis(xaxis_data=year)
    y1 = [100, 200, 300, 400, 100, 400, 300]
    for i in genre_list:
        line.add_yaxis(series_name=i, y_axis=gen_year_sum[i])
    line.set_global_opts(title_opts=opts.TitleOpts(title="电影类型变化趋势", ))
    line.set_series_opts(label_opts=opts.LabelOpts(is_show=False))
    line.render_notebook()
    page.add(line)

5.2.1.4 不同电影类型预算/利润（绘制组合图）

def Budget():
    df["type"] = df["genres"].str.split(",")
    df_explode = df.explode("type")
    df_all = df_explode.groupby(['type']).mean()  # 求平均值
    budget = df_all['budget'].round(2)
    revenue = df_all['revenue'].round(2)
    bili = list((revenue / budget).round(2))
    bud = list(budget)
    rev = list(revenue)
    budg = []
    reve = []
    for i in bud:
        budg.append(round(i / 100000000, 2))
    for i in rev:
        reve.append(round(i / 100000000, 2))
    diary_budget = dict(zip(df_all.index.values.tolist(), bili))
    d_order = sorted(diary_budget.items(), key=lambda x: x[1], reverse=False)
    keys = []
    values = []
    for key, value in d_order:
        keys.append(key)
        values.append(value)
    line = (
        Line(init_opts=opts.InitOpts(width="100%", theme=ThemeType.LIGHT))  # 这里可以选择主题
            .add_xaxis(df_all.index.values.tolist())
            .add_yaxis("利润/预算", bili, stack="stack1", yaxis_index=1)
            .extend_axis(
            yaxis=opts.AxisOpts(
                axislabel_opts=opts.LabelOpts(formatter="{value}%")
            )
        )
            .set_series_opts(label_opts=opts.LabelOpts(is_show=False, position='right'))
            .set_global_opts(
            title_opts=opts.TitleOpts(title="不同电影类型预算/利润"),
            yaxis_opts=opts.AxisOpts(
                axislabel_opts=opts.LabelOpts(formatter="{value}/千万")
            ),
            tooltip_opts=opts.TooltipOpts(
                is_show=True, trigger="axis", axis_pointer_type="cross"
            ),
            xaxis_opts=opts.AxisOpts(
                type_="category",
                axispointer_opts=opts.AxisPointerOpts(is_show=True, type_="shadow"),
                axislabel_opts=opts.LabelOpts(rotate=-15)
            )

        )
    )
    bar = Bar()
    bar.add_xaxis(df_all.index.values.tolist()).add_yaxis("平均预算", budg, stack="stack1").add_yaxis("平均利润", reve,
                                                                                                  stack="stack1")
    bar.set_series_opts(label_opts=opts.LabelOpts(is_show=False, position='left'))
    line.overlap(bar)
    page.add(line)

5.2.2 电影关键词（keywords 关键词分析，绘制词云图）

def KeywordsWordcloud():
    movie_keywords = []
    genres = df['keywords'].values.tolist()
    for genre in genres:
        genre_list = str(genre).split(',')
        for i in genre_list:
            item = changeStr(i)
            if item:  # 为空列表  滤掉
                movie_keywords.append(item)
    movie_type = pd.DataFrame(movie_keywords, index=None, columns=['type'])
    df_grp = movie_type.apply(pd.value_counts)
    diary_type = dict(zip(df_grp.index.values.tolist(), df_grp['type'].tolist()))
    d_order = sorted(diary_type.items(), key=lambda x: x[1], reverse=False)
    mywordcloud = WordCloud(init_opts=opts.InitOpts(width="100%"))
    mywordcloud.add('', d_order, shape='circle')
    page.add(mywordcloud)

5.3 when

查看 runtime 的类型，发现是 object 类型，也就是字符串，所以，先进行数据转化。

print(df.runtime)

先将其转换为数值类型，int

df.runtime = df.runtime.astype(int)
print(df.runtime))

5.3.1 电影时长（绘制电影时长直方图）

直方图pyecharts画不了

所以使用matplotlib画

def RunTime():
    df.runtime = df.runtime.astype(float)
    sns.set_style('white')
    movie_duration = df.runtime
    plt.figure(figsize=(20, 8), dpi=100)
    # 设置组距
    distance = 5
    group_num = int((max(movie_duration) - min(movie_duration)) / distance)
    # 计算组数
    # 绘制直方图用 数据、组数 两个参数
    plt.hist(movie_duration, bins=group_num)
    plt.rcParams['font.sans-serif'] = ['SimHei']
    plt.rcParams['axes.unicode_minus'] = False
    plt.xticks(range(int(min(movie_duration)), int(max(movie_duration)))[::5])
    plt.grid(linestyle='--', alpha=0.5)
    plt.xlabel('电影时长大小')
    plt.ylabel('电影的数据量')
    plt.savefig('img/电影时长直方图.png')
    plt.show()

5.3.2 发行时间（绘制每月电影数量和单片平均票房）

def MonthAnalyse():
    df['release_month'] = pd.to_datetime(df.release_date, format='%Y-%m-%d', errors='coerce').dt.month
    df_revenue = df.groupby(['release_month']).revenue.mean()
    df_number = df.groupby(['release_month']).size()
    x = ['1月', '2月', '3月', '4月', '5月', '6月', '7月', '8月', '9月', '10月', '11月', '12月']
    y2 = []
    for k in df_revenue.tolist():
        y2.append(round(k / 1000000, 2))
    bar = Bar(init_opts=opts.InitOpts(width="100%", theme=ThemeType.MACARONS))
    bar.add_xaxis(x)
    bar.add_yaxis("电影数量", df_number.values.tolist())
    bar.add_yaxis("单片平均票房/百万", y2)
    bar.set_series_opts(label_opts=opts.LabelOpts(is_show=False, position='right'))
    bar.set_global_opts(title_opts=opts.TitleOpts(title="每月电影数量和单片平均票房"))
    page.add(bar)

5.4 where

本数据集收集的是美国地区的电影数据，对于电影的制作公司以及制作国家，在本次的故事背景下不作分析。

5.5 who

5.5.1 分析票房分布及票房 Top10 的导演

def RevenueSpread():
    # dr['name'] = dr['name'].apply(lambda x: ',' + x)
    # dr1 = dr.groupby(by='movie_id').sum()
    #
    # dr1['name'] = dr1['name'].apply(lambda x: x[1:])
    # dr1.to_csv("dire.csv")
    # print(dr1)
    sns.set_style('white')
    movie_duration = df['revenue']
    ss = []
    for i in movie_duration.values.tolist():
        ss.append(round(i / 100000000, 2))
    print(ss)
    plt.figure(figsize=(20, 8), dpi=100)
    # 设置组距
    distance = 5
    group_num = int(max(ss) - min(ss))
    # 计算组数
    # 绘制直方图用 数据、组数 两个参数
    plt.hist(ss, bins=group_num)
    plt.rcParams['font.sans-serif'] = ['SimHei']
    plt.rcParams['axes.unicode_minus'] = False
    plt.xticks(range(int(min(ss)), int(max(ss)))[::1])
    plt.grid(linestyle='--', alpha=0.5)
    plt.xlabel('电影票房/亿')
    plt.ylabel('电影的数据量')
    plt.savefig('img/票房分布.png')
    plt.show()

    dr_sort = dr.groupby('name').sum().sort_values(by='revenue', ascending=False)
    dr_top10 = dr_sort.head(10).sort_values(by='revenue', ascending=True)
    piaofang = []
    for i in dr_top10['revenue'].values.tolist():
        piaofang.append(round(i / 100000000, 2))
    bar = Bar(init_opts=opts.InitOpts(width="100%"))
    bar.add_xaxis(dr_top10.index.values.tolist())
    bar.add_yaxis("总票房/亿", piaofang)
    bar.set_series_opts(label_opts=opts.LabelOpts(is_show=True, position='right'))
    bar.reversal_axis()
    bar.set_global_opts(title_opts=opts.TitleOpts(title="Top10导演"))
    page.add(bar)

5.5.2 分析评分分布及评分 Top10 的导演

def VoteSpread():
    sns.set_style('white')
    movie_average = df['vote_average']
    print(movie_average)
    plt.figure(figsize=(20, 8), dpi=100)
    # 设置组距
    distance = 5
    group_num = int((max(movie_average) - min(movie_average)))
    # 计算组数
    # 绘制直方图用 数据、组数 两个参数
    plt.hist(movie_average, bins=group_num)
    plt.rcParams['font.sans-serif'] = ['SimHei']
    plt.rcParams['axes.unicode_minus'] = False
    plt.xticks(range(0, 10)[::1])
    plt.grid(linestyle='--', alpha=0.5)
    plt.xlabel('电影评分')
    plt.ylabel('电影的数据量')
    plt.savefig('img/评分分布.png')
    plt.show()

    dr_sort = dr.groupby('name').mean().sort_values(by=['vote_average', 'vote_count'], ascending=False)
    print(dr_sort['vote_average'].head(10))
    dr_top10 = dr_sort.head(10).sort_values(by='vote_average', ascending=True)
    bar = Bar(init_opts=opts.InitOpts(width="100%", theme=ThemeType.LIGHT))
    bar.add_xaxis(dr_top10.index.values.tolist())
    bar.add_yaxis("评分", dr_top10['vote_average'].values.tolist())
    bar.set_series_opts(label_opts=opts.LabelOpts(is_show=True, position='right'))
    bar.reversal_axis()
    bar.set_global_opts(title_opts=opts.TitleOpts(title="评分Top10导演"))
    page.add(bar)

发现数据中大多数电影都是8分，没有小数位，导致统计结果出现相同情况，所以按照在评分为8的前提下，根据popularity又进行了一次排序

5.6 how

5.6.1 原创 VS 改编占比（饼图）

def getBaseOnNovel():
    count = 0
    for i in df['keywords'].values.tolist():
        print(i)
        if "based on novel" in str(i):
            count = count + 1
    print((len(df.values.tolist()) - count) / len(df.values.tolist()))
    pie = Pie(init_opts=opts.InitOpts(width="100%", height="700px"))
    name = ["原创", "改编"]
    value = [len(df.values.tolist()) - count, count]

    pie.add("", [list(z) for z in zip(name, value)])  # zip函数两个部分组合在一起list(zip(x,y))-----> [(x,y)]
    pie.set_global_opts(title_opts=opts.TitleOpts(title="原创 VS 改编"))  # 标题
    pie.set_series_opts(label_opts=opts.LabelOpts(formatter="{b}: {d}%"))  # 数据标签设置

    pie.render('first_bar.html')
    page.add(pie)

5.6.2 原创 VS 改编预算/利润率（组合图）

def getLilv():
    count = 0
    var = df[df['keywords'].str.contains('based on novel', na=True)]
    df_based = var.sum()
    df_all = df.sum()
    based_budg = df_based['budget']
    based_reve = df_based['revenue']
    ori_budg = df_all['budget'] - df_based['budget']
    ori_reve = df_all['revenue'] - df_based['revenue']
    yusuan = [round(ori_budg / (df.shape[0] - var.shape[0]) / 10000000, 2),
              round((based_budg / var.shape[0]) / 10000000, 2)]
    lirun = [round(ori_reve / (df.shape[0] - var.shape[0]) / 10000000, 2),
             round((based_reve / var.shape[0]) / 10000000, 2)]
    lilv = [round(ori_reve / ori_budg, 2), round(based_reve / based_budg, 2)]
    line = (
        Line(init_opts=opts.InitOpts(width="50%", theme=ThemeType.LIGHT))  # 这里可以选择主题
            .add_xaxis(['原创', '改编'])
            .add_yaxis("利润率", lilv, stack="stack1", yaxis_index=1)
            .extend_axis(
            yaxis=opts.AxisOpts(
                axislabel_opts=opts.LabelOpts(formatter="{value}%")
            )
        )
            .set_series_opts(label_opts=opts.LabelOpts(is_show=False, position='right'))
            .set_global_opts(
            title_opts=opts.TitleOpts(title="原创 VS 改编预算/利润率"),
            yaxis_opts=opts.AxisOpts(
                axislabel_opts=opts.LabelOpts(formatter="{value}/千万")
            ),
            tooltip_opts=opts.TooltipOpts(
                is_show=True, trigger="axis", axis_pointer_type="cross"
            ),
            xaxis_opts=opts.AxisOpts(
                type_="category",
                axispointer_opts=opts.AxisPointerOpts(is_show=True, type_="shadow"),
            )

        )
    )
    bar = Bar()
    bar.add_xaxis(['原创', '改编']).add_yaxis("平均预算", yusuan, stack="stack1").add_yaxis("平均利润", lirun, stack="stack1")
    bar.set_series_opts(label_opts=opts.LabelOpts(is_show=False, position='left'))
    line.overlap(bar)
    page.add(line)

5.7 how much

5.7.1 计算相关系数（票房相关系数矩阵）

def RelatedNumber():
    df.drop(columns=['id', 'ids'], inplace=True)
    print(df)
    dfData = df.corr()
    plt.subplots(figsize=(9, 9))  # 设置画面大小
    sns.heatmap(dfData, annot=True, vmax=1, square=True, cmap="Oranges")
    plt.savefig('img/相关系数矩阵.png')
    plt.show()

5.7.2 票房影响因素散点图

def sandiantu():
    scatter = Scatter(init_opts=opts.InitOpts(width="100%", theme=ThemeType.LIGHT))
    scatter.add_xaxis(df['budget'])
    scatter.add_yaxis("利润", df['revenue'])
    scatter.set_global_opts(
        xaxis_opts=opts.AxisOpts(
            type_="value",
            name="预算",
        ),
        yaxis_opts=opts.AxisOpts(
            name="利润"
        )
    )
    scatter.set_series_opts(label_opts=opts.LabelOpts(is_show=False, position='left'))
    scatter.set_global_opts(title_opts=opts.TitleOpts(title="预算对利润的影响散点图"))

    scatter1 = Scatter(init_opts=opts.InitOpts(width="100%", theme=ThemeType.LIGHT))
    scatter1.add_xaxis(df['runtime'])
    scatter1.add_yaxis("利润", df['revenue'])
    scatter1.set_global_opts(
        xaxis_opts=opts.AxisOpts(
            type_="value",
            name="电影时长",
        ),
        yaxis_opts=opts.AxisOpts(
            name="利润"
        )
    )
    scatter1.set_series_opts(label_opts=opts.LabelOpts(is_show=False, position='right'))
    scatter1.set_global_opts(title_opts=opts.TitleOpts(title="电影时长对利润的影响散点图"))

    scatter2 = Scatter(init_opts=opts.InitOpts(width="100%", theme=ThemeType.LIGHT))
    scatter2.add_xaxis(df['vote_average'])
    scatter2.add_yaxis("利润", df['revenue'])
    scatter2.set_global_opts(
        xaxis_opts=opts.AxisOpts(
            type_="value",
            name="评分",
        ),
        yaxis_opts=opts.AxisOpts(
            name="利润"
        )
    )
    scatter2.set_series_opts(label_opts=opts.LabelOpts(is_show=False, position='right'))
    scatter2.set_global_opts(title_opts=opts.TitleOpts(title="评分对利润的影响散点图"))

    scatter3 = Scatter(init_opts=opts.InitOpts(width="100%", theme=ThemeType.LIGHT))
    scatter3.add_xaxis(df['vote_count'])
    scatter3.add_yaxis("利润", df['revenue'])
    scatter3.set_global_opts(
        xaxis_opts=opts.AxisOpts(
            type_="value",
            name="评分人数",
        ),
        yaxis_opts=opts.AxisOpts(
            name="利润"
        )
    )
    scatter3.set_series_opts(label_opts=opts.LabelOpts(is_show=False, position='right'))
    scatter3.set_global_opts(title_opts=opts.TitleOpts(title="评分人数对利润的影响散点图"))

    scatter4 = Scatter(init_opts=opts.InitOpts(width="100%", theme=ThemeType.LIGHT))
    scatter4.add_xaxis(df['popularity'])
    scatter4.add_yaxis("利润", df['revenue'])
    scatter4.set_global_opts(
        xaxis_opts=opts.AxisOpts(
            type_="value",
            name="受欢迎度",
        ),
        yaxis_opts=opts.AxisOpts(
            name="利润"
        )
    )
    scatter4.set_series_opts(label_opts=opts.LabelOpts(is_show=False, position='right'))
    scatter4.set_global_opts(title_opts=opts.TitleOpts(title="受欢迎度对利润的影响散点图"))

    scatter5 = Scatter(init_opts=opts.InitOpts(width="100%", theme=ThemeType.LIGHT))
    #range(1950, 2020, 1)
    scatter5.add_xaxis(df['release_year'])
    scatter5.add_yaxis("利润", df['revenue'])
    scatter5.set_global_opts(
        xaxis_opts=opts.AxisOpts(
            type_="value",
            name="上映年份",
            min_=1900
        ),
        yaxis_opts=opts.AxisOpts(
            name="利润"
        )
    )
    scatter5.set_series_opts(label_opts=opts.LabelOpts(is_show=False, position='right'))
    scatter5.set_global_opts(title_opts=opts.TitleOpts(title="上映年份对利润的影响散点图"))
    page.add(scatter, scatter1, scatter2, scatter3,scatter4,scatter5)

6 对附件的 tmdb_1000_predicted.csv 的预测结果

使用sklearn对tmdb_1000_predicted.csv进行预测

from sklearn.cross_decomposition import PLSCanonical
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.neighbors import NearestNeighbors
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression, SGDRegressor, Ridge, RidgeCV, Lasso, ElasticNet, BayesianRidge, \
    LogisticRegression
from sklearn.metrics import mean_squared_error
import joblib
import pandas as pd
from sklearn.svm import SVR
import numpy as np
def dump_load_demo():
    # 1.获取数据
    df = pd.read_csv('total_2431.csv', sep=',', engine='python', header=[0])
    feature_arr = df[['budget', 'popularity', 'revenue', 'runtime']].values
    tag_arr = df['vote_count'].values
    print(len(tag_arr))
    # 2.数据基本处理
    # 2.1 数据集划分
    x_train, x_test, y_train, y_test = train_test_split(feature_arr,tag_arr[:,np.newaxis], random_state=350, test_size=0.2)

    # 3.特征工程 --标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.fit_transform(x_test)

    # 4.机器学习(线性回归)
    # 4.1 模型训练
    estimator =Ridge()

    estimator.fit(x_train, y_train)
    print("这个模型的偏置是:\n", estimator.intercept_)

    # 4.2 模型保存
    joblib.dump(estimator, "save/test.pkl")

    # 4.3 模型加载
    estimator = joblib.load("save/test.pkl")

    # 5.模型评估
    # 5.1 预测值和准确率
    y_pre = estimator.predict(x_test)
    print("预测值是:\n", y_pre)
    score = estimator.score(x_test, y_test)
    print("准确率是:\n", score)
    ret = mean_squared_error(y_test, y_pre)
    print("均方误差是:\n", ret)

if __name__ == '__main__':
    dump_load_demo()

正确率75%，很难再往上调了。

预测支持人数：

预测评分：

综上所述，我们可以得到如下结论：

1.剧情类，喜剧类，惊悚类，动作类电影类型量较多，占据所有类型的50%，且这些类型数量也在不断增长，因此电影类型可以向这四类靠拢。

2.根据关键词词云，可以发现based on novel数量较多，电影可以着手尝试小说改编，同时，violence、murder，revenge，sequel，prison，police也不少，可以拍摄监狱犯罪、暴力对抗，不断复仇，且有续集的电影。

3.根据预算与利润我们可以分析出来：

① 总体来说，这些电影类型都是盈利的，不同的是利润率

② 还有预算的投入

③ 虽然Documentary类型电影的利润率最高，但是预算低，它的利润相对来说也低，如果是小成本电影公司的话，可以尝试此类电影，如果事大公司可以尝试高预算且高利润的电影，比如Animation，Family，Fantasy，Advanture等等，都有着相对较高的利润

4.根据每月电影数量和单片平均票房，发现电影数量在6、9、12月数量较多，而电影票房在5月份最高，其次是6、11、12，因此，可以尝试在5月发行电影，有着数量较少的电影，可以减少竞争力，还有着不错的票房收入。

5.根据电影时长分布，电影控制在98~108分钟是最好的选择。

6.根据电影票房分布，发现总体票房集中在1~2亿美元之间

7.根据票房Top10导演，票房最高为史蒂芬·斯皮尔伯格，第二彼得·杰克逊，第三詹姆斯·卡梅隆，第四迈克尔·贝，可以尝试找这些导演拍摄影片，这些都是电影票房的保障，可以获得许多利润。

8.根据评分分布，发现大部分电影评分集中在7~8分之间

9.根据评分Top10导演，可以选择詹姆斯·马什，丹·吉尔罗伊，约什·布恩等等导演，这些导演的影片评分都很不错，可以留下较好的名誉。

10.根据原创VS改编，发现还是原创居多，可以尝试原创，但是改编也是不错的选择。根据原创VS改编的利润率，发现改编要比原创高，所以可以尝试改编，毕竟还有很多原著党。

11.根据相关系数矩阵，可以发现电影影响因素有很多，期间相互影响也是甚多，比如vote_count与票房就有很大的关系，vote_count和popularity有着71%的联系，预算与票房也达到了69%的关系，但是也从中看出，评分对票房的影响并不大，呈现负数，可能是跟数据本身有关。

12.根据散点图，得到以下分析：

①预算对票房的影响是逐步上升的，想要提高票房可以适当提高预算。

②电影时长集中在100-150分钟可以有更高的票房

③评分人数越多，会有更高的票房

④受欢迎度对票房的影响是逐步上升的，受欢迎度越高，票房也就越高。

观影大数据分析

推荐阅读