精华内容
下载资源
问答
  • 本文首先逐条评价了现有关联度四公理的意义,指出规范和接近是必不可少的,整体和偶对对称是没有必要的,接近需要用严谨数学语言描述,适用范围没有必要局限在系统...
  • 关联性和变形量化

    2020-03-31 05:26:47
    非交换和非缔合在弦论中很自然。 对于开放弦,它的出现是由于Dirichlet皮膜的世界体积中存在不消失的背景二形式,而在闭合弦理论中,... 总而言之,我们在替代星产品的代数上定义了积分,并表明积分联想器消失了。
  • 可信度或置信度是针对一条诸如{尿布}->{葡萄酒}的关联规则来定义的。这条规则的可信度被定义为“支持度({尿布,葡萄酒})/支持度({尿布})”。 寻找频繁项集 Apriori原理:如果某个项集是频繁的,那么它的所有子集也是...
  • 1.为自定义类型定义 2.定义仿函数,并在关联性容器定义时作为模板参数传过去 参考资料:http://blog.csdn.net/jinzhilong580231/article/details/8666877

    1.为自定义类型定义<运算符

    2.定义仿函数,并在关联性容器定义时作为模板参数传过去

    参考资料:http://blog.csdn.net/jinzhilong580231/article/details/8666877

    展开全文
  • 运算符优先级和关联性

    千次阅读 2014-04-10 21:47:52
    C++ 语言包括所有 C 运算符并添加多个新的运算符。 运算符指定对下列项之一执行计算: ...运算符遵循严格的优先级,该优先级定义了包含这些运算符的表达式...下表显示 C++ 运算符的优先级和关联性(从最高优先级

    C++ 语言包括所有 C 运算符并添加多个新的运算符。 运算符指定对下列项之一执行计算:

    • 一个操作数(一元运算符)

    • 两个操作数(二元运算符)

    • 三个操作数(三元运算符)

    运算符遵循严格的优先级,该优先级定义了包含这些运算符的表达式的计算顺序。 运算符与其左侧或右侧的表达式关联;这称为“关联性”。下表显示 C++ 运算符的优先级和关联性(从最高优先级到最低优先级)。 表的同一段中的运算符具有相同的优先级,这些运算符在表达式中按给定顺序进行计算(除非括号明确强制执行计算)。

    C++ 运算符的优先级和关联性

    运算符

    名称或含义

    结合性

    ::

    范围解析

     

     

     

    .

    成员选定内容(对象)

    从左到右

    –>

    成员选定内容(指针)

    从左到右

    [ ]

    数组下标

    从左到右

    ( )

    函数调用成员初始化

    从左到右

    ++

    后缀递增

    从左到右

    ––

    后缀递减

    从左到右

    typeid( )

    类型名称

    从左到右

    const_cast

    类型转换(转换)

    从左到右

    dynamic_cast

    类型转换(转换)

    从左到右

    reinterpret_cast

    类型转换(转换)

    从左到右

    static_cast

    类型转换(转换)

    从左到右

     

     

     

    sizeof

    对象或类型的大小

    从右到左

    ++

    前缀递增

    从右到左

    ––

    前缀递减

    从右到左

    ~

    二进制反码

    从右到左

    !

    逻辑“非”

    从右到左

    一元负

    从右到左

    +

    一元加

    从右到左

    &

    address-of

    从右到左

    *

    间接寻址

    从右到左

    new

    创建对象

    从右到左

    delete

    销毁对象

    从右到左

    ( )

    Cast

    从右到左

     

     

     

    .*

    指向成员的指针(对象)

    从左到右

    –>*

    指向成员的指针(指针)

    从左到右

     

     

     

    *

    乘法

    从左到右

    /

    除法

    从左到右

    %

    取模

    从左到右

     

     

     

    +

    添加

    从左到右

    减法

    从左到右

     

     

     

    <<

    左移

    从左到右

    >>

    右移

    从左到右

     

     

     

    <

    小于

    从左到右

    >

    大于

    从左到右

    <=

    小于或等于

    从左到右

    >=

    大于或等于

    从左到右

     

     

     

    ==

    相等

    从左到右

    !=

    不相等

    从左到右

     

     

     

    &

    按位“与”

    从左到右

     

     

     

    ^

    按位“异或”

    从左到右

     

     

     

    |

    按位“与或”

    从左到右

     

     

     

    &&

    逻辑“与”

    从左到右

     

     

     

    ||

    逻辑“或”

    从左到右

     

     

     

    expr1 expr2 : expr3

    条件运算

    从右到左

     

     

     

    =

    赋值

    从右到左

    *=

    乘法赋值

    从右到左

    /=

    除法赋值

    从右到左

    %=

    取模赋值

    从右到左

    +=

    加法赋值

    从右到左

    –=

    减法赋值

    从右到左

    <<=

    左移赋值

    从右到左

    >>=

    右移赋值

    从右到左

    &=

    按位“与”赋值

    从右到左

    |=

    按位“与或”赋值

    从右到左

    ^=

    按位“异或”赋值

    从右到左

     

     

     

    throw expr

    引发表达式

    从右到左

     

     

     

    ,

    逗号

    从左到右

    展开全文
  • C++顺序性容器、关联性容器与容器适配器 什么是容器 首先,我们必须理解一下什么是容器,在C++ 中容器被定义为:在数据存储上,有一种对象类型,它可以持有其它对象或指向其它对像的指针,这种对象类型就叫做容器...

     

    C++顺序性容器、关联性容器与容器适配器

    什么是容器

    首先,我们必须理解一下什么是容器,在C++ 中容器被定义为:在数据存储上,有一种对象类型,它可以持有其它对象或指向其它对像的指针,这种对象类型就叫做容器。很简单,容器就是保存其它对象的对象,当然这是一个朴素的理解,这种“对象”还包含了一系列处理“其它对象”的方法,因为这些方法在程序的设计上会经常被用到,所以容器也体现了一个好处,就是“容器类是一种对特定代码重用问题的良好的解决方案”。

    容器还有另一个特点是容器可以自行扩展。在解决问题时我们常常不知道我们需要存储多少个对象,也就是说我们不知道应该创建多大的内存空间来保存我们的对象。显然,数组在这一方面也力不从心。容器的优势就在这里,它不需要你预先告诉它你要存储多少对象,只要你创建一个容器对象,并合理的调用它所提供的方法,所有的处理细节将由容器来自身完成。它可以为你申请内存或释放内存,并且用最优的算法来执行您的命令。

    容器是随着面向对象语言的诞生而提出的,容器类在面向对象语言中特别重要,甚至它被认为是早期面向对象语言的基础。在现在几乎所有的面向对象的语言中也都伴随着一个容器集,在C++ 中,就是标准模板库(STL )。

    和其它语言不一样,C++ 中处理容器是采用基于模板的方式。标准C++ 库中的容器提供了多种数据结构,这些数据结构可以与标准算法一起很好的工作,这为我们的软件开发提供了良好的支持!

    通用容器的分类

    STL 对定义的通用容器分三类:顺序性容器、关联式容器和容器适配器。

    顺序性容器 是一种各元素之间有顺序关系的线性表,是一种线性结构的可序群集。顺序性容器中的每个元素均有固定的位置,除非用删除或插入的操作改变这个位置。这个位置和元素本身无关,而和操作的时间和地点有关,顺序性容器不会根据元素的特点排序而是直接保存了元素操作时的逻辑顺序。比如我们一次性对一个顺序性容器追加三个元素,这三个元素在容器中的相对位置和追加时的逻辑次序是一致的。

    关联式容器 和顺序性容器不一样,关联式容器是非线性的树结构,更准确的说是二叉树结构。各元素之间没有严格的物理上的顺序关系,也就是说元素在容器中并没有保存元素置入容器时的逻辑顺序。但是关联式容器提供了另一种根据元素特点排序的功能,这样迭代器就能根据元素的特点“顺序地”获取元素。

    关联式容器另一个显著的特点是它是以键值的方式来保存数据,就是说它能把关键字和值关联起来保存,而顺序性容器只能保存一种(可以认为它只保存关键字,也可以认为它只保存值)。这在下面具体的容器类中可以说明这一点。

    容器适配器 是一个比较抽象的概念, C++的解释是:适配器是使一事物的行为类似于另一事物的行为的一种机制。容器适配器是让一种已存在的容器类型采用另一种不同的抽象类型的工作方式来实现的一种机制。其实仅是发生了接口转换。那么你可以把它理解为容器的容器,它实质还是一个容器,只是他不依赖于具体的标准容器类型,可以理解是容器的模版。或者把它理解为容器的接口,而适配器具体采用哪种容器类型去实现,在定义适配器的时候可以由你决定。

    下表列出STL 定义的三类容器所包含的具体容器类:

    标准容器类

    特点

    顺序性容器

    vector

    从后面快速的插入与删除,直接访问任何元素

    deque

    从前面或后面快速的插入与删除,直接访问任何元素

    list

    双链表,从任何地方快速插入与删除

    关联容器

    set

    快速查找,不允许重复值

    multiset

    快速查找,允许重复值

    map

    一对多映射,基于关键字快速查找,不允许重复值

    multimap

    一对多映射,基于关键字快速查找,允许重复值

    容器适配器

    stack

    后进先出

    queue

    先进先出

    priority_queue

    最高优先级元素总是第一个出列

     

    顺序性容器

     

    向量 vector :  

    是一个线性顺序结构。相当于数组,但其大小可以不预先指定,并且自动扩展。它可以像数组一样被操作,由于它的特性我们完全可以将vector 看作动态数组。
    在创建一个vector 后,它会自动在内存中分配一块连续的内存空间进行数据存储,初始的空间大小可以预先指定也可以由vector 默认指定,这个大小即capacity ()函数的返回值。当存储的数据超过分配的空间时vector 会重新分配一块内存块,但这样的分配是很耗时的,在重新分配空间时它会做这样的动作:

    首先,vector 会申请一块更大的内存块;

    然后,将原来的数据拷贝到新的内存块中;

    其次,销毁掉原内存块中的对象(调用对象的析构函数);

    最后,将原来的内存空间释放掉。

    如果vector 保存的数据量很大时,这样的操作一定会导致糟糕的性能(这也是vector 被设计成比较容易拷贝的值类型的原因)。所以说vector 不是在什么情况下性能都好,只有在预先知道它大小的情况下vector 的性能才是最优的。

    vector 的特点:
    (1) 指定一块如同数组一样的连续存储,但空间可以动态扩展。即它可以像数组一样操作,并且可以进行动态操作。通常体现在push_back() pop_back() 。
    (2) 随机访问方便,它像数组一样被访问,即支持[ ] 操作符和vector.at()
    (3) 节省空间,因为它是连续存储,在存储数据的区域都是没有被浪费的,但是要明确一点vector 大多情况下并不是满存的,在未存储的区域实际是浪费的。

    (4) 在内部进行插入、删除操作效率非常低,这样的操作基本上是被禁止的。Vector 被设计成只能在后端进行追加和删除操作,其原因是vector 内部的实现是按照顺序表的原理。
    (5) 只能在vector 的最后进行push 和pop ,不能在vector 的头进行push 和pop 。
    (6) 当动态添加的数据超过vector 默认分配的大小时要进行内存的重新分配、拷贝与释放,这个操作非常消耗性能。 所以要vector 达到最优的性能,最好在创建vector 时就指定其空间大小。

    双向链表list

    是一个线性链表结构,它的数据由若干个节点构成,每一个节点都包括一个信息块(即实际存储的数据)、一个前驱指针和一个后驱指针。它无需分配指定的内存大小且可以任意伸缩,这是因为它存储在非连续的内存空间中,并且由指针将有序的元素链接起来。

    由于其结构的原因,list 随机检索的性能非常的不好,因为它不像vector 那样直接找到元素的地址,而是要从头一个一个的顺序查找,这样目标元素越靠后,它的检索时间就越长。检索时间与目标元素的位置成正比。

    虽然随机检索的速度不够快,但是它可以迅速地在任何节点进行插入和删除操作。因为list 的每个节点保存着它在链表中的位置,插入或删除一个元素仅对最多三个元素有所影响,不像vector 会对操作点之后的所有元素的存储地址都有所影响,这一点是vector 不可比拟的。

    list 的特点:
    (1) 不使用连续的内存空间这样可以随意地进行动态操作;
    (2) 可以在内部任何位置快速地插入或删除,当然也可以在两端进行push 和pop 。
    (3) 不能进行内部的随机访问,即不支持[ ] 操作符和vector.at() ;
    (4) 相对于verctor 占用更多的内存。

    双端队列deque 
    是一种优化了的、对序列两端元素进行添加和删除操作的基本序列容器。它允许较为快速地随机访问,但它不像vector 把所有的对象保存在一块连续的内存块,而是采用多个连续的存储块,并且在一个映射结构中保存对这些块及其顺序的跟踪。向deque 两端添加或删除元素的开销很小。它不需要重新分配空间,所以向末端增加元素比vector 更有效。

    实际上,deque 是对vector 和list 优缺点的结合,它是处于两者之间的一种容器。

    deque 的特点:
    (1) 随机访问方便,即支持[ ] 操作符和vector.at() ,但性能没有vector 好;
    (2) 可以在内部进行插入和删除操作,但性能不及list ;
    (3) 可以在两端进行push 、pop ;

    三者的比较

    下图描述了vector 、list 、deque 在内存结构上的特点:

     

    vector 是一段连续的内存块,而deque 是多个连续的内存块, list 是所有数据元素分开保存,可以是任何两个元素没有连续。

    vector 的查询性能最好,并且在末端增加数据也很好,除非它重新申请内存段;适合高效地随机存储。

    list 是一个链表,任何一个元素都可以是不连续的,但它都有两个指向上一元素和下一元素的指针。所以它对插入、删除元素性能是最好的,而查询性能非常差;适合 大量地插入和删除操作而不关心随机存取的需求。

    deque 是介于两者之间,它兼顾了数组和链表的优点,它是分块的链表和多个数组的联合。所以它有被list 好的查询性能,有被vector 好的插入、删除性能。 如果你需要随即存取又关心两端数据的插入和删除,那么deque 是最佳之选。

    关联容器

    set, multiset, map, multimap 是一种非线性的树结构,具体的说采用的是一种比较高效的特殊的平衡检索二叉树—— 红黑树结构。(至于什么是红黑树,我也不太理解,只能理解到它是一种二叉树结构)

    因为关联容器的这四种容器类都使用同一原理,所以他们核心的算法是一致的,但是它们在应用上又有一些差别,先描述一下它们之间的差别。

    set ,又称集合,实际上就是一组元素的集合,但其中所包含的元素的值是唯一的,且是按一定顺序排列的,集合中的每个元素被称作集合中的实例。因为其内部是通过链表的方式来组织,所以在插入的时候比vector 快,但在查找和末尾添加上被vector 慢。

    multiset ,是多重集合,其实现方式和set 是相似的,只是它不要求集合中的元素是唯一的,也就是说集合中的同一个元素可以出现多次。

    map ,提供一种“键- 值”关系的一对一的数据存储能力。其“键”在容器中不可重复,且按一定顺序排列(其实我们可以将set 也看成是一种键- 值关系的存储,只是它只有键没有值。它是map 的一种特殊形式)。由于其是按链表的方式存储,它也继承了链表的优缺点。

    multimap , 和map 的原理基本相似,它允许“键”在容器中可以不唯一。

    关联容器的特点是明显的,相对于顺序容器,有以下几个主要特点:

    1, 其内部实现是采用非线性的二叉树结构,具体的说是红黑树的结构原理实现的;

    2, set 和map 保证了元素的唯一性,mulset 和mulmap 扩展了这一属性,可以允许元素不唯一;

    3, 元素是有序的集合,默认在插入的时候按升序排列。

    基于以上特点,

    1, 关联容器对元素的插入和删除操作比vector 要快,因为vector 是顺序存储,而关联容器是链式存储;比list 要慢,是因为即使它们同是链式结构,但list 是线性的,而关联容器是二叉树结构,其改变一个元素涉及到其它元素的变动比list 要多,并且它是排序的,每次插入和删除都需要对元素重新排序;

    2, 关联容器对元素的检索操作比vector 慢,但是比list 要快很多。vector 是顺序的连续存储,当然是比不上的,但相对链式的list 要快很多是因为list 是逐个搜索,它搜索的时间是跟容器的大小成正比,而关联容器 查找的复杂度基本是Log(N) ,比如如果有1000 个记录,最多查找10 次,1,000,000 个记录,最多查找20 次。容器越大,关联容器相对list 的优越性就越能体现;

    3, 在使用上set 区别于vector,deque,list 的最大特点就是set 是内部排序的,这在查询上虽然逊色于vector ,但是却大大的强于list 。

    4, 在使用上map 的功能是不可取代的,它保存了“键- 值”关系的数据,而这种键值关系采用了类数组的方式。数组是用数字类型的下标来索引元素的位置,而map 是用字符型关键字来索引元素的位置。在使用上map 也提供了一种类数组操作的方式,即它可以通过下标来检索数据,这是其他容器做不到的,当然也包括set 。(STL 中只有vector 和map 可以通过类数组的方式操作元素,即如同ele[1] 方式)

    容器适配器

    STL 中包含三种适配器:栈stack 、队列queue 和优先级priority_queue 。

    适配器是容器的接口,它本身不能直接保存元素,它保存元素的机制是调用另一种顺序容器去实现,即可以把适配器看作“它保存一个容器,这个容器再保存所有元素”。

    STL 中提供的三种适配器可以由某一种顺序容器去实现。默认下stack 和queue 基于deque 容器实现,priority_queue 则基于vector 容器实现。当然在创建一个适配器时也可以指定具体的实现容器,创建适配器时在第二个参数上指定具体的顺序容器可以覆盖适配器的默认实现。

    由于适配器的特点,一个适配器不是可以由任一个顺序容器都可以实现的。

    栈stack 的特点是后进先出,所以它关联的基本容器可以是任意一种顺序容器,因为这些容器类型结构都可以提供栈的操作有求,它们都提供了push_back 、pop_back 和back 操作;

    队列queue 的特点是先进先出,适配器要求其关联的基础容器必须提供pop_front 操作,因此其不能建立在vector 容器上;

    优先级队列priority_queue 适配器要求提供随机访问功能,因此不能建立在list 容器上。

    展开全文
  • 游戏关联性专题分析

    2020-11-17 12:25:38
    在这个流量越来越贵的时代,渠道方常常面临一个问题:拿到CP给的游戏之后该如何投放游戏,除了根据产品和运营人员定义的品类标签定向投放之外,还有没有其他更精准利用流量的方式进行投放? 大部分时候,我们拿到...

    1、前言

    1.1项目背景

    • 在这个流量越来越贵的时代,渠道方常常面临一个问题:拿到CP给的游戏之后该如何投放游戏,除了根据产品和运营人员定义的品类标签定向投放之外,还有没有其他更精准利用流量的方式进行投放?
    • 大部分时候,我们拿到游戏后会有2-3天的冷启动测试阶段,那冷启动测试阶段的用户行为数据如何作为依据为后续投放做数据支撑?

    1.2分析目标

    • 假设喜欢A游戏的用户,大概率也喜欢B游戏,那么我们就可以针对玩过A游戏的这部分用户群体定向投放B游戏。我们需要根据历史用户行为数据计算所有游戏受用户喜欢的相关性,然后根据相关性锁定游戏投放的目标群体定向投放。

    1.3分析思路

    1. 评估用户对游戏的喜爱程度
    2. 计算用户同时喜欢两种游戏的用户数
    3. 两两游戏组合按照用户数高低排序,用户数较高的游戏组合即表示该组游戏受用户喜欢相关性较高
    4. 计算相关性矩阵得到所有游戏的相关性图谱

    1.4分析模型

    本次分析共涉及两种模型,矩阵模型和相似度计算模型

    矩阵模型:

    X轴和Y轴分别表示用户玩游戏的单次时长和玩游戏的频次,我们定义用户喜欢该游戏的标准为同时满足下面两个条件:

    • 玩该游戏的单次时长大于该游戏的平均时长
    • 玩游戏频次大于该游戏所有用户的平均频次

    在这里插入图片描述

    相似度计算模型:

    这里应用到基于物品的协同过滤算法,两个物品产生相似度是因为它们共同被很多用户喜欢,也就是说每个用户都可以通过他们的历史兴趣列表给物品“贡献”相似度,相似度计算包含两步:

    • 计算两两组合的物品被用户喜欢的频次矩阵C

    在这里插入图片描述

    • 对C矩阵做归一化处理,得到余弦相似度矩阵W,矩阵里的值在0-1范围,越靠近1表示该组合物品越相似

    在这里插入图片描述

    说明:N(i)表示喜欢i物品的用户人数,分子表示同时喜欢物品i和物品j的用户数

    2、理解数据

    2.1数据集

    该数据来源于某渠道2020/09/18-2020/09/20三天的用户行为数据,已去除敏感字段,共包含10万多条用户行为,数据集地址:密码:fiun

    2.2字段含义

    该数据共包含4个字段:

    • user_id:用户ID
    • game_id:游戏ID
    • time_long:用户单次玩游戏时长(单位:分钟)
    • timestamp:用户玩游戏时间戳

    3、数据清洗和预处理

    # 引入第三方库
    import pandas as pd
    import numpy as np
    import matplotlib.pyplot as plt
    import math
    import seaborn as sns
    
    # 读取数据,并设置字段名称
    data_user = pd.read_csv('user_game_data.csv',names=["user_id","game_id","time_long","timestamp"])
    #探寻数据
    data_user.head()
    
    user_id game_id time_long timestamp
    0 1 1 12 2020/9/18 21:17
    1 5 19 12 2020/9/20 10:14
    2 7 21 14 2020/9/18 19:17
    3 15 7 8 2020/9/20 16:35
    4 17 20 14 2020/9/19 5:06
    # 查看数据基本信息
    data_user.info()
    
    <class 'pandas.core.frame.DataFrame'>
    RangeIndex: 100836 entries, 0 to 100835
    Data columns (total 4 columns):
    user_id      100836 non-null int64
    game_id      100836 non-null int64
    time_long    100836 non-null int64
    timestamp    100836 non-null object
    dtypes: int64(3), object(1)
    memory usage: 3.1+ MB
    

    说明:该数据共包含100836条数据,各项字段数据完整,无缺失值处理

    # 查看time_long(玩游戏单次时长)有无异常值
    data_user["time_long"].describe()
    
    count    100836.000000
    mean         10.670267
    std           4.521110
    min           0.000000
    25%           9.000000
    50%          11.000000
    75%          12.000000
    max         980.000000
    Name: time_long, dtype: float64
    

    说明:time_long最大值是980分钟,数据异常

    # 处理异常值:time_long(用户玩游戏单次时长正常范围是0-100分钟,超过100分钟的用平均值代替)
    data_user['time_long']=data_user['time_long'].apply(lambda x:data_user["time_long"].mean() if x>100 else x)
    # 查看处理后的time_long分布
    data_user["time_long"].describe()
    
    count    100836.000000
    mean         10.654634
    std           3.114415
    min           0.000000
    25%           9.000000
    50%          11.000000
    75%          12.000000
    max          15.000000
    Name: time_long, dtype: float64
    
    # 查看有无异常用户(用户一天平均每天玩游戏次数大于100次默认为该用户刷机)
    game_count=data_user.groupby(["user_id","game_id"])["time_long"].apply(lambda x : math.ceil(x.count()/3)).sort_values(ascending=False)
    game_count.head(10)
    
    user_id  game_id
    414      12         36
    599      11         35
    414      10         35
    474      11         32
    599      12         31
    414      11         31
             3          30
             27         30
    474      5          28
    599      29         28
    Name: time_long, dtype: int64
    

    说明:用户无刷机行为,无异常数据处理

    4、数据分析和可视化

    # 求用户对游戏的喜爱程度,用户喜欢该游戏需同时满足:1、时长大于该游戏时长均值;2、频次大于该游戏频次均值
    #求每个游戏的单次平均时长,和单天玩游戏的平均频次
    game_mean=data_user.groupby("game_id").aggregate({"time_long":"mean","user_id":lambda x:math.ceil(x.count()/len(x.unique())/3)}).reset_index().rename(columns={"time_long":"game_time_mean","user_id":"game_play_count"})
    game_mean.head()
    
    game_id game_time_mean game_play_count
    0 1 10.964778 1
    1 2 11.322742 1
    2 3 10.613494 2
    3 4 10.624354 2
    4 5 10.609121 2
    # 求每个用户玩每个游戏的平均游戏时长和游戏频次
    user_mean=data_user.groupby(["user_id","game_id"]).aggregate({"time_long":"mean","timestamp":lambda x:math.ceil(x.count()/3)}).reset_index().rename(columns={"time_long":"time_mean","timestamp":"play_count"})
    user_mean.head()
    
    user_id game_id time_mean play_count
    0 1 1 13.0 1
    1 1 2 13.0 1
    2 1 4 13.0 1
    3 1 6 15.0 1
    4 1 7 15.0 1
    # 查找time_mean>game_time_mean,且play_count>game_play_count的用户数据
    user_game_data = pd.merge(user_mean,game_mean)
    user_game_data=user_game_data[(user_game_data['time_mean']>user_game_data['game_time_mean'])&(user_game_data['play_count']>user_game_data['game_play_count'])]
    user_game_data.head()
    
    user_id game_id time_mean play_count game_time_mean game_play_count
    55 103 1 13.000 2 10.964778 1
    77 140 1 11.625 3 10.964778 1
    91 171 1 13.500 2 10.964778 1
    108 202 1 12.500 2 10.964778 1
    126 246 1 13.000 2 10.964778 1
    # 查找两两游戏被用户同时喜欢的人数
    merge_data=pd.merge(user_game_data[['user_id','game_id']],user_game_data[['user_id','game_id']],on='user_id')
    # game_id_x>game_id_y:过滤AB和BA这种情况,只保留AB组合
    count_data=merge_data[merge_data['game_id_x']>merge_data['game_id_y']].groupby(['game_id_x','game_id_y']).count().rename(columns={'user_id':'共同喜欢的人数'}).sort_values("共同喜欢的人数",ascending=False).reset_index()
    count_data.head(10)
    
    game_id_x game_id_y 共同喜欢的人数
    0 41 24 36
    1 41 35 36
    2 42 37 36
    3 41 37 36
    4 40 39 36
    5 41 40 36
    6 40 25 36
    7 38 25 35
    8 36 32 35
    9 37 32 35

    说明:运营人员可根据前10组游戏组合,选择对应用户群体定向投放,提高游戏用户质量

    # 求所有游戏的相似度矩阵
    #思路:定义相关性函数,得到频次矩阵C,再频次矩阵C的基础上,归一化得到余弦相似度矩阵W
    def get_W(train):
        # 先求相似矩阵C
        C = dict() #共同喜欢两个游戏的人数
        N = dict() # 喜欢某一个游戏的人数
        for t, item in train.items():
            for i in item:
                if(i in N):
                    N[i]+=1
                else:
                    N[i]=1
                for j in item:
                    if i == j:
                        continue
                    if (i in C):
                        if(j in C[i]):
                            C[i].update({j: C[i][j] + 1})
                        else:
                            C[i][j]=1
                    else:
                        C.update({i: {j: 1}})
        # 再对C矩阵做归一化处理得到余弦相似度矩阵W
        W = dict()
        for i, item_i in C.items():
            for j, item_j in item_i.items():
                add_dict(W,i,j,"%.2f" % (C[i][j] / math.sqrt(N[i] * N[j])))
        return W
    # 定位添加二维字典元素的方法
    def add_dict(dict,key1,key2,val):
        if(key1 in dict):
            dict[key1].update({key2:val})
        else:
            dict.update({key1:{key2:val}})
    # 构建数据集
    train=dict()
    for i in user_game_data['user_id']:
        train[i]=user_game_data[user_game_data['user_id']==i]['game_id'].values.tolist()
    W = get_W(train)
    new_W=pd.DataFrame(W).fillna(0).sort_index(axis=1).astype("float64")
    # 相关性矩阵
    new_W
    
    1 2 3 4 5 6 7 8 9 10 ... 40 41 42 43 44 45 46 47 48 49
    1 0.00 0.06 0.14 0.12 0.20 0.27 0.04 0.15 0.12 0.23 ... 0.26 0.29 0.26 0.20 0.22 0.17 0.24 0.11 0.19 0.14
    2 0.06 0.00 0.18 0.19 0.23 0.19 0.17 0.26 0.20 0.14 ... 0.31 0.28 0.25 0.10 0.22 0.17 0.06 0.33 0.23 0.27
    3 0.14 0.18 0.00 0.47 0.52 0.47 0.50 0.45 0.45 0.40 ... 0.50 0.48 0.46 0.45 0.16 0.23 0.14 0.23 0.27 0.16
    4 0.12 0.19 0.47 0.00 0.46 0.46 0.46 0.53 0.44 0.41 ... 0.48 0.52 0.36 0.34 0.14 0.21 0.18 0.14 0.27 0.04
    5 0.20 0.23 0.52 0.46 0.00 0.51 0.56 0.46 0.44 0.49 ... 0.54 0.48 0.50 0.40 0.24 0.29 0.22 0.17 0.32 0.17
    6 0.27 0.19 0.47 0.46 0.51 0.00 0.61 0.36 0.51 0.46 ... 0.47 0.49 0.41 0.36 0.31 0.28 0.25 0.21 0.32 0.21
    7 0.04 0.17 0.50 0.46 0.56 0.61 0.00 0.50 0.54 0.51 ... 0.48 0.41 0.37 0.30 0.23 0.24 0.16 0.23 0.19 0.19
    8 0.15 0.26 0.45 0.53 0.46 0.36 0.50 0.00 0.58 0.52 ... 0.47 0.43 0.36 0.30 0.21 0.25 0.22 0.21 0.26 0.17
    9 0.12 0.20 0.45 0.44 0.44 0.51 0.54 0.58 0.00 0.55 ... 0.40 0.40 0.38 0.32 0.22 0.23 0.23 0.18 0.25 0.14
    10 0.23 0.14 0.40 0.41 0.49 0.46 0.51 0.52 0.55 0.00 ... 0.38 0.40 0.33 0.33 0.21 0.21 0.13 0.21 0.25 0.15
    11 0.15 0.15 0.49 0.41 0.51 0.48 0.53 0.45 0.43 0.43 ... 0.41 0.41 0.38 0.48 0.10 0.18 0.11 0.14 0.17 0.13
    12 0.08 0.16 0.61 0.45 0.48 0.44 0.52 0.55 0.47 0.44 ... 0.52 0.52 0.39 0.56 0.08 0.19 0.16 0.23 0.19 0.14
    13 0.18 0.22 0.39 0.31 0.36 0.33 0.40 0.44 0.35 0.27 ... 0.44 0.36 0.32 0.39 0.24 0.29 0.13 0.16 0.20 0.20
    14 0.23 0.18 0.38 0.29 0.35 0.40 0.32 0.34 0.27 0.24 ... 0.45 0.42 0.38 0.47 0.21 0.34 0.22 0.12 0.21 0.10
    15 0.27 0.13 0.29 0.40 0.40 0.28 0.25 0.37 0.33 0.34 ... 0.44 0.39 0.37 0.39 0.16 0.29 0.26 0.08 0.28 0.15
    16 0.09 0.26 0.34 0.34 0.42 0.25 0.31 0.47 0.32 0.27 ... 0.37 0.30 0.46 0.32 0.20 0.33 0.21 0.16 0.27 0.20
    17 0.25 0.28 0.45 0.44 0.49 0.43 0.39 0.38 0.32 0.37 ... 0.53 0.50 0.42 0.45 0.29 0.26 0.23 0.33 0.28 0.41
    18 0.20 0.19 0.43 0.37 0.41 0.41 0.37 0.39 0.28 0.32 ... 0.46 0.48 0.40 0.55 0.14 0.18 0.18 0.24 0.24 0.22
    19 0.20 0.12 0.35 0.33 0.38 0.42 0.38 0.44 0.42 0.39 ... 0.55 0.45 0.45 0.50 0.14 0.18 0.11 0.11 0.21 0.18
    20 0.29 0.20 0.38 0.39 0.44 0.41 0.34 0.36 0.27 0.31 ... 0.51 0.51 0.43 0.49 0.22 0.23 0.20 0.30 0.19 0.28
    21 0.15 0.18 0.46 0.38 0.52 0.44 0.47 0.42 0.37 0.42 ... 0.50 0.46 0.44 0.53 0.17 0.17 0.14 0.24 0.28 0.25
    22 0.17 0.22 0.36 0.36 0.43 0.39 0.35 0.32 0.26 0.30 ... 0.41 0.41 0.38 0.31 0.26 0.21 0.27 0.26 0.26 0.32
    23 0.17 0.24 0.42 0.41 0.43 0.47 0.48 0.47 0.48 0.44 ... 0.55 0.49 0.50 0.35 0.19 0.22 0.16 0.22 0.29 0.23
    24 0.26 0.28 0.49 0.49 0.49 0.52 0.45 0.56 0.45 0.41 ... 0.58 0.60 0.48 0.38 0.29 0.27 0.28 0.20 0.34 0.25
    25 0.16 0.41 0.51 0.47 0.49 0.53 0.50 0.53 0.54 0.49 ... 0.61 0.52 0.52 0.36 0.32 0.30 0.12 0.35 0.35 0.29
    26 0.33 0.36 0.47 0.37 0.46 0.41 0.40 0.55 0.51 0.49 ... 0.57 0.56 0.55 0.43 0.26 0.34 0.17 0.23 0.28 0.33
    27 0.23 0.22 0.47 0.41 0.55 0.48 0.45 0.45 0.43 0.46 ... 0.57 0.55 0.55 0.54 0.28 0.25 0.11 0.21 0.32 0.17
    28 0.23 0.22 0.46 0.43 0.40 0.47 0.47 0.49 0.43 0.37 ... 0.51 0.46 0.49 0.42 0.17 0.21 0.07 0.24 0.26 0.21
    29 0.34 0.26 0.52 0.40 0.45 0.54 0.52 0.47 0.47 0.45 ... 0.64 0.56 0.50 0.44 0.27 0.31 0.21 0.24 0.34 0.25
    30 0.23 0.16 0.48 0.33 0.48 0.51 0.41 0.39 0.37 0.44 ... 0.53 0.49 0.46 0.47 0.21 0.27 0.16 0.24 0.28 0.15
    31 0.26 0.25 0.41 0.33 0.44 0.39 0.49 0.58 0.42 0.44 ... 0.57 0.51 0.48 0.44 0.27 0.27 0.21 0.27 0.25 0.25
    32 0.23 0.23 0.46 0.40 0.48 0.54 0.46 0.45 0.37 0.37 ... 0.56 0.56 0.50 0.45 0.24 0.25 0.16 0.24 0.25 0.19
    33 0.28 0.24 0.42 0.39 0.48 0.45 0.34 0.37 0.35 0.39 ... 0.52 0.50 0.50 0.41 0.19 0.29 0.17 0.22 0.32 0.16
    34 0.24 0.13 0.41 0.49 0.38 0.40 0.40 0.38 0.38 0.38 ... 0.51 0.52 0.45 0.43 0.18 0.25 0.22 0.24 0.31 0.08
    35 0.32 0.25 0.43 0.38 0.50 0.47 0.40 0.43 0.38 0.43 ... 0.54 0.59 0.46 0.43 0.20 0.26 0.15 0.23 0.24 0.25
    36 0.19 0.18 0.49 0.45 0.43 0.54 0.45 0.46 0.47 0.44 ... 0.56 0.56 0.53 0.47 0.22 0.26 0.18 0.17 0.28 0.21
    37 0.29 0.16 0.56 0.43 0.47 0.46 0.42 0.46 0.36 0.39 ... 0.58 0.60 0.60 0.51 0.20 0.24 0.21 0.20 0.30 0.25
    38 0.24 0.27 0.48 0.39 0.41 0.41 0.40 0.45 0.36 0.39 ... 0.59 0.58 0.53 0.52 0.19 0.29 0.13 0.19 0.29 0.19
    39 0.23 0.28 0.41 0.35 0.45 0.44 0.40 0.42 0.34 0.34 ... 0.60 0.51 0.50 0.41 0.26 0.24 0.21 0.26 0.22 0.18
    40 0.26 0.31 0.50 0.48 0.54 0.47 0.48 0.47 0.40 0.38 ... 0.00 0.59 0.57 0.53 0.23 0.26 0.15 0.23 0.34 0.32
    41 0.29 0.28 0.48 0.52 0.48 0.49 0.41 0.43 0.40 0.40 ... 0.59 0.00 0.54 0.45 0.26 0.26 0.18 0.23 0.29 0.25
    42 0.26 0.25 0.46 0.36 0.50 0.41 0.37 0.36 0.38 0.33 ... 0.57 0.54 0.00 0.43 0.29 0.32 0.15 0.17 0.31 0.25
    43 0.20 0.10 0.45 0.34 0.40 0.36 0.30 0.30 0.32 0.33 ... 0.53 0.45 0.43 0.00 0.04 0.18 0.09 0.04 0.11 0.11
    44 0.22 0.22 0.16 0.14 0.24 0.31 0.23 0.21 0.22 0.21 ... 0.23 0.26 0.29 0.04 0.00 0.31 0.21 0.35 0.34 0.43
    45 0.17 0.17 0.23 0.21 0.29 0.28 0.24 0.25 0.23 0.21 ... 0.26 0.26 0.32 0.18 0.31 0.00 0.22 0.15 0.30 0.13
    46 0.24 0.06 0.14 0.18 0.22 0.25 0.16 0.22 0.23 0.13 ... 0.15 0.18 0.15 0.09 0.21 0.22 0.00 0.21 0.18 0.20
    47 0.11 0.33 0.23 0.14 0.17 0.21 0.23 0.21 0.18 0.21 ... 0.23 0.23 0.17 0.04 0.35 0.15 0.21 0.00 0.30 0.31
    48 0.19 0.23 0.27 0.27 0.32 0.32 0.19 0.26 0.25 0.25 ... 0.34 0.29 0.31 0.11 0.34 0.30 0.18 0.30 0.00 0.21
    49 0.14 0.27 0.16 0.04 0.17 0.21 0.19 0.17 0.14 0.15 ... 0.32 0.25 0.25 0.11 0.43 0.13 0.20 0.31 0.21 0.00

    49 rows × 49 columns

    # 可视化
    fig, ax = plt.subplots(figsize = (30,30),dpi=200)
    # mask用于只显示左下角矩阵
    mask = np.zeros_like(new_W, dtype=np.bool)
    mask[np.triu_indices_from(mask)] = True
    sns.heatmap(new_W, mask=mask,annot=True, xticklabels= True, yticklabels= True, square=True, cmap="YlGnBu")
    ax.set_ylabel('game_id', fontsize = 18)
    ax.set_xlabel('game_id', fontsize = 18) 
    
    Text(0.5, 1096.4444444444443, 'game_id')
    

    在这里插入图片描述

    5、结论和建议

    • 以下游戏组合的行为相关性较高,可针对对应游戏的用户群体进行投放,提高游戏投放价值,后续可通过ABTEST验证投放对应群体和不投放对应群体游戏的各项关键指标(ecpm、游戏时长、游戏频次等)有无变化来验证相关性的效果

      (备注:更详细的游戏相关性信息可参考上图相关性矩阵,颜色越深代表两个游戏的相关性越高)
    game_id_x game_id_y 共同喜欢的人数
    0 41 24 36
    1 41 35 36
    2 42 37 36
    3 41 37 36
    4 40 39 36
    5 41 40 36
    6 40 25 36
    7 38 25 35
    8 36 32 35
    9 37 32 35
    10 41 36 35
    11 35 24 35
    12 40 37 35
    13 40 36 35
    14 42 40 35
    15 40 24 35
    16 37 24 34
    17 36 25 34
    18 37 36 34
    19 41 38 33
    展开全文
  • 【原创】C++ 集合set与关联性容器

    千次阅读 2017-05-03 14:01:04
    关联性容器 set与map 引入 map和set常常用,但是不太了解,不太深入。想要深入的了解,发现网上的全是一些高级的东西,讲讲了map和set的定义,但是并没有或是很少提及用法。想看用法,只得翻百度百科或是...
  • 研究拓扑特征之间的关联性对于简化拓扑建模具有重要的意义。dK特征序列理论上能够计算得到所有的网络拓扑特征,因此可以用来进行拓扑特征的关联性研究。在分析dK序列定义的基础上,推导出一些重要的网络拓扑特征与dK...
  • 文章转载自:http://www.cnblogs.com/dyllove98/p/3214898.htmlSTL 对定义的通用容器分三类:顺序容器、关联式容器和容器适配器。顺序容器:是一种各元素之间有顺序关系的线性表,是一种线性结构的可序群集。...
  • @Mapper注解和@MapperScan注解的关联性,以及源码分析。 @Mapper注解和@MapperScan注解是我们使用mybatis-spring的常用注解,之前为了探究两个注解的关联性,百度了一波的文章,都将@Mapper注解和@MapperScan注解...
  • 顺序性容器:vector、list、deque关联性容器:set、multiset、map、multimap容器适配器:stack、queue、priority_queue本篇主要总结关联性容器:(btw:获取迭代器的方法:建对象方式::iterator iter; //例:map&...
  • //第7章 线程调度、优先级和关联性.cpp: 定义应用程序的入口点。 // #include "stdafx.h" #include "第7章 线程调度、优先级和关联性.h" //线程函数 DWORD WINAPI ThreadProc(PVOID param) { ...
  • ”一“的客观形态与主观感受之间的关联性研究 逻辑上而言,每个”一“的感受都来源于其形态,那么我们不禁要问,各个”一“带来的不同感受与它们的形态有何关联呢?为了探索”形态-感受“的关联性,需要对每个”一...
  • 从大规模数据集中寻找物品间的隐含关系被称作关联分析或关联规则学习。过程分为两步:1.提取频繁项集。2.从频繁项集中抽取出关联规则。 频繁项集是指经常出现在一块的物品的集合。 关联规则是暗示两种物品之间可能...
  • 为了探索”形态-感受“的关联性,需要对每个”一“的客观造型进行描述,提取特征,这里就需要用到图像处理的技术了。有兴趣的同学可以尝试完成下列任务: 任务主题:针对”一“,定义一系列特征(可借鉴参考资料)...
  • 针对指标值为区间灰数时决策信息得不到充分利用的问题,在决策...在TOPSIS理论基础上,建立区间灰数序列间的灰色关联的测度方法,进而构建灰色关联一致系数决策模型.最后通过算例分析表明所构建模型的可行和有效.
  • "一"的客观形态与主观感受之间的关联性研究任务主题任务要求提交内容特征定义笔划长度笔划宽度笔力走势(斜率)起笔点处斜率收笔点处斜率骨架提取手工测量笔划长度笔画宽度最大宽度最小宽度平均宽度笔力走势总体走势...
  • 为了探索”形态-感受“的关联性,需要对每个”一“的客观造型进行描述,提取特征,这里就需要用到图像处理的技术了。 研究内容 针对”一“,定义一系列特征,并依此对每个”一“进行测量。测量可以分两个层次:1....
  • 首先,我们必须理解一下什么是容器,在C++中容器被定义为:在数据存储上,有一种对象类型,它可以持有其它对象或指向其它对像的指针,这种对象类型就叫做容器。很简单,容器就是保存其它对象的对象,当然这是一个...
  • Res/目录下定义好values、layout等,生成对应的类即R.java。 AndroidMainfest.xml中定义application、ativity、intent等,每个activity对应一个Java文件。Java文件中实现此activity的整个生命周期,从onCreate()...
  • 目录:前言卡方检验定义什么是 (具体原理)两个分类变量的关联性分析前言:前面两篇文章谈到了TzeSing:简单相关性分析(两个连续型变量)​zhuanlan.zhihu.comTzeSing:多变量相关性分析(一个因变量与多个自变量)​...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,681
精华内容 1,472
关键字:

关联性定义