https://wiki.mozilla.org/Audio_Data_API

推荐系统最早在亚马逊的网站上应用，根据以往用户的购买行为，推荐出购买某种产品同时可能购买的其他产品。

直接打分需要用户的参与程度比较高，很多网站都在内容页中留一个打分的按钮，从1～5选一 个，我可能喜欢这篇文章，可我哪里知道我喜欢的程度是几分啊，还要我去思考，而网站设计中一条很重要的原则是:Do not let me think!，于是我就胡打一个分数或者不打，而隐性的打分则不同，只有你喜欢的图书你才会购买，只有你喜欢的歌曲才会听多次。

最近邻搜索算法一般是皮尔森相关系数（Person Correlation Coefficient）、余弦相似性（Cosine-based Similarity）以及调整余弦相似性（Adjusted Cosine Similarity）。关于余弦定理在数据挖掘中的应用，google黑白报有过介绍，可以参考数学之美 系列 12 - 余弦定理和新闻的分类。

基本原理

用户	对事物A打分	对事物B打分
X	3	4
Y	2	4
Z	4	?

用户Z对事物B的打分可能是多少呢？股票上有个说法是平均值可以掩盖一切异常波动，所以股票上的各个技术指标收拾不同时间段的平均值的曲线图或者柱 状图等。同样的，Slope one算法也认为：平均值也可以代替某两个未知个体之间的打分差异，事物A对事物B的平均很差是：((3 - 4) + (2 - 4)) / 2 = -1.5，也就是说人们对事物B的打分一般比事物A的打分要高1.5，于是Slope one算法就猜测Z对事物B的打分是4 + 1.5 = 5.5

加权算法

有n个人对事物A和事物B打分了，R(A->B)表示这n个人对A和对B打分的平均差（A-B）,有m个人对事物B和事物C打分 了，R（C->B）表示这m个人对C和对B打分的平均差（C-B），注意都是平均差而不是平方差，现在某个用户对A的打分是ra，对C的打分是 rc，那么A对B的打分可能是：

rb = (n * (ra - R(A->B)) + m * (rc - R(C->B)))/(m+n)

 
# This is the code in plain text out of the technical report. 
# 
# Daniel Lemire, Sean McGrath, Implementing a Rating-Based Item-to-Item 
# Recommender System in PHP/SQL, Technical Report D-01, January 2005. 
# 
# http://www.ondelette.com/lemire/abstracts/TRD01.html 
# 
# This code is in the public domain, use at your own risks. 
# It is assumed that you looked at the report and know some SQL and PHP. 
# 
# Daniel Lemire, February 3rd 2005 
# 
# First part is sample SQL code. 
#########CUT HERE#################### 
 
CREATE TABLE rating ( 
    userID INT PRIMARY KEY, 
    itemID INT NOT NULL, 
    ratingValue INT NOT NULL, 
    datetimestamp TIMESTAMP NOT NULL 
); 
 
 
CREATE TABLE dev ( 
  itemID1 int(11) NOT NULL default '0', 
  itemID2 int(11) NOT NULL default '0', 
  count int(11) NOT NULL default '0', 
  sum int(11) NOT NULL default '0', 
  PRIMARY KEY  (itemID1,itemID2) 
); 
 
 
# simple query to output 10 most liked items 
# by people who rated item 1 
SELECT itemID2, ( sum / count ) AS average 
FROM dev 
WHERE count > 2 AND itemID1 = 1 
ORDER  BY ( sum / count ) DESC 
LIMIT 10; 
 
# Next part is sample PHP code. 
#########CUT HERE#################### 
 
// This code assumes $itemID is set to that of  
// the item that was just rated.  
// Get all of the user's rating pairs 
$sql = "SELECT DISTINCT r.itemID, r2.ratingValue - r.ratingValue  
            as rating_difference 
            FROM rating r, rating r2 
            WHERE r.userID=$userID AND  
                    r2.itemID=$itemID AND  
                    r2.userID=$userID;"; 
$db_result = mysql_query($sql, $connection); 
$num_rows = mysql_num_rows($db_result); 
//For every one of the user's rating pairs,  
//update the dev table 
while ($row = mysql_fetch_assoc($db_result)) { 
    $other_itemID = $row["itemID"]; 
    $rating_difference = $row["rating_difference"]; 
    //if the pair ($itemID, $other_itemID) is already in the dev table 
    //then we want to update 2 rows. 
    if (mysql_num_rows(mysql_query("SELECT itemID1  
    FROM dev WHERE itemID1=$itemID AND itemID2=$other_itemID", 
    $connection)) > 0)  { 
        $sql = "UPDATE dev SET count=count+1,  
    sum=sum+$rating_difference WHERE itemID1=$itemID  
    AND itemID2=$other_itemID"; 
        mysql_query($sql, $connection); 
    //We only want to update if the items are different                 
        if ($itemID != $other_itemID) { 
            $sql = "UPDATE dev SET count=count+1,  
        sum=sum-$rating_difference  
        WHERE (itemID1=$other_itemID AND itemID2=$itemID)"; 
            mysql_query($sql, $connection); 
        } 
    } 
    else { //we want to insert 2 rows into the dev table 
        $sql = "INSERT INTO dev VALUES ($itemID, $other_itemID, 
        1, $rating_difference)"; 
        mysql_query($sql, $connection);  
    //We only want to insert if the items are different        
        if ($itemID != $other_itemID) {          
            $sql = "INSERT INTO dev VALUES ($other_itemID,  
        $itemID, 1, -$rating_difference)"; 
            mysql_query($sql, $connection); 
        } 
    }     
} 
 
 
function predict($userID, $itemID) { 
    global $connection;     
    $denom = 0.0; //denominator 
    $numer = 0.0; //numerator     
    $k = $itemID;     
    $sql = "SELECT r.itemID, r.ratingValue  
    FROM rating r WHERE r.userID=$userID AND r.itemID <> $itemID"; 
    $db_result = mysql_query($sql, $connection);         
    //for all items the user has rated 
    while ($row = mysql_fetch_assoc($db_result))  { 
        $j = $row["itemID"]; 
        $ratingValue = $row["ratingValue"];         
        //get the number of times k and j have both been rated by the same user 
        $sql2 = "SELECT d.count, d.sum FROM dev d WHERE itemID1=$k AND itemID2=$j"; 
        $count_result = mysql_query($sql2, $connection);         
        //skip the calculation if it isn't found 
        if(mysql_num_rows($count_result) > 0)  { 
            $count = mysql_result($count_result, 0, "count"); 
            $sum = mysql_result($count_result, 0, "sum");             
            //calculate the average 
            $average = $sum / $count;             
            //increment denominator by count 
            $denom += $count;             
            //increment the numerator 
            $numer += $count * ($average + $ratingValue); 
        }         
    }     
    if ($denom == 0) 
        return 0; 
    else 
        return ($numer / $denom); 
} 
 
 
function predict_all($userID ) { 
    $sql2 = "SELECT d.itemID1 as 'item', sum(d.count) as 'denom',  
    sum(d.sum + d.count*r.ratingValue) as 'numer' FROM item i, rating r, 
    dev d WHERE r.userID=$userID  
    AND d.itemID1<>r.itemID  
    AND d.itemID2=r.itemID GROUP BY d.itemID1"; 
    return mysql_query($sql2, $connection); 
} 

Java：

import java.util.*; 
/** 
* Daniel Lemire 
* A simple implementation of the weighted slope one 
* algorithm in Java for item-based collaborative  
* filtering.  
* Assumes Java 1.5. 
* 
* See main function for example. 
* 
* June 1st 2006. 
* Revised by Marco Ponzi on March 29th 2007 
*/ 
 
public class SlopeOne { 
   
  public static void main(String args[]){ 
    // this is my data base 
    Map<UserId,Map<ItemId,Float>> data = new HashMap<UserId,Map<ItemId,Float>>(); 
    // items 
    ItemId item1 = new ItemId("       candy"); 
    ItemId item2 = new ItemId("         dog"); 
    ItemId item3 = new ItemId("         cat"); 
    ItemId item4 = new ItemId("         war"); 
    ItemId item5 = new ItemId("strange food"); 
     
    mAllItems = new ItemId[]{item1, item2, item3, item4, item5}; 
     
    //I'm going to fill it in 
    HashMap<ItemId,Float> user1 = new HashMap<ItemId,Float>(); 
    HashMap<ItemId,Float> user2 = new HashMap<ItemId,Float>(); 
    HashMap<ItemId,Float> user3 = new HashMap<ItemId,Float>(); 
    HashMap<ItemId,Float> user4 = new HashMap<ItemId,Float>(); 
    user1.put(item1,1.0f); 
    user1.put(item2,0.5f); 
    user1.put(item4,0.1f); 
    data.put(new UserId("Bob"),user1); 
    user2.put(item1,1.0f); 
    user2.put(item3,0.5f); 
    user2.put(item4,0.2f); 
    data.put(new UserId("Jane"),user2); 
    user3.put(item1,0.9f); 
    user3.put(item2,0.4f); 
    user3.put(item3,0.5f); 
    user3.put(item4,0.1f); 
    data.put(new UserId("Jo"),user3);     
    user4.put(item1,0.1f); 
    //user4.put(item2,0.4f); 
    //user4.put(item3,0.5f); 
    user4.put(item4,1.0f); 
    user4.put(item5,0.4f); 
    data.put(new UserId("StrangeJo"),user4);     
    // next, I create my predictor engine 
    SlopeOne so = new SlopeOne(data); 
    System.out.println("Here's the data I have accumulated..."); 
    so.printData(); 
    // then, I'm going to test it out... 
    HashMap<ItemId,Float> user = new HashMap<ItemId,Float>(); 
    System.out.println("Ok, now we predict..."); 
    user.put(item5,0.4f); 
    System.out.println("Inputting..."); 
    SlopeOne.print(user); 
    System.out.println("Getting..."); 
    SlopeOne.print(so.predict(user)); 
    // 
    user.put(item4,0.2f); 
    System.out.println("Inputting..."); 
    SlopeOne.print(user); 
    System.out.println("Getting..."); 
    SlopeOne.print(so.predict(user)); 
  } 
   
  Map<UserId,Map<ItemId,Float>> mData; 
  Map<ItemId,Map<ItemId,Float>> mDiffMatrix; 
  Map<ItemId,Map<ItemId,Integer>> mFreqMatrix; 
   
  static ItemId[] mAllItems; 
   
  public SlopeOne(Map<UserId,Map<ItemId,Float>> data) { 
    mData = data; 
    buildDiffMatrix();     
  } 
   
  /** 
  * Based on existing data, and using weights, 
  * try to predict all missing ratings. 
  * The trick to make this more scalable is to consider 
  * only mDiffMatrix entries having a large  (>1) mFreqMatrix 
  * entry. 
  * 
  * It will output the prediction 0 when no prediction is possible. 
  */ 
  public Map<ItemId,Float> predict(Map<ItemId,Float> user) { 
    HashMap<ItemId,Float> predictions = new HashMap<ItemId,Float>(); 
    HashMap<ItemId,Integer> frequencies = new HashMap<ItemId,Integer>(); 
    for (ItemId j : mDiffMatrix.keySet()) { 
      frequencies.put(j,0); 
      predictions.put(j,0.0f); 
    } 
    for (ItemId j : user.keySet()) { 
      for (ItemId k : mDiffMatrix.keySet()) { 
        try { 
        float newval = ( mDiffMatrix.get(k).get(j).floatValue() + user.get(j).floatValue() ) * mFreqMatrix.get(k).get(j).intValue(); 
        predictions.put(k, predictions.get(k)+newval); 
        frequencies.put(k, frequencies.get(k)+mFreqMatrix.get(k).get(j).intValue()); 
        } catch(NullPointerException e) {} 
      } 
    } 
    HashMap<ItemId,Float> cleanpredictions = new HashMap<ItemId,Float>(); 
    for (ItemId j : predictions.keySet()) { 
        if (frequencies.get(j)>0) { 
          cleanpredictions.put(j, predictions.get(j).floatValue()/frequencies.get(j).intValue()); 
        } 
    } 
    for (ItemId j : user.keySet()) { 
         cleanpredictions.put(j,user.get(j)); 
    } 
    return cleanpredictions; 
  } 
   
  /** 
  * Based on existing data, and not using weights, 
  * try to predict all missing ratings. 
  * The trick to make this more scalable is to consider 
  * only mDiffMatrix entries having a large  (>1) mFreqMatrix 
  * entry. 
  */ 
  public Map<ItemId,Float> weightlesspredict(Map<ItemId,Float> user) { 
    HashMap<ItemId,Float> predictions = new HashMap<ItemId,Float>(); 
    HashMap<ItemId,Integer> frequencies = new HashMap<ItemId,Integer>(); 
    for (ItemId j : mDiffMatrix.keySet()) { 
      predictions.put(j,0.0f); 
      frequencies.put(j,0); 
    } 
    for (ItemId j : user.keySet()) { 
      for (ItemId k : mDiffMatrix.keySet()) { 
        //System.out.println("Average diff between "+j+" and "+ k + " is "+mDiffMatrix.get(k).get(j).floatValue()+" with n = "+mFreqMatrix.get(k).get(j).floatValue()); 
        float newval = ( mDiffMatrix.get(k).get(j).floatValue() + user.get(j).floatValue() ) ; 
        predictions.put(k, predictions.get(k)+newval); 
      } 
    } 
    for (ItemId j : predictions.keySet()) { 
        predictions.put(j, predictions.get(j).floatValue()/user.size()); 
    } 
    for (ItemId j : user.keySet()) { 
      predictions.put(j,user.get(j)); 
    } 
    return predictions; 
  } 
 
 
  public void printData() { 
        for(UserId user : mData.keySet()) { 
          System.out.println(user); 
          print(mData.get(user)); 
        } 
        for (int i=0; i<mAllItems.length; i++) { 
            System.out.print("\n" + mAllItems[i] + ":"); 
            printMatrixes(mDiffMatrix.get(mAllItems[i]), mFreqMatrix.get(mAllItems[i])); 
        } 
      } 
 
    private void printMatrixes(Map<ItemId,Float> ratings, 
                Map<ItemId,Integer> frequencies) {   
            for (int j=0; j<mAllItems.length; j++) { 
                System.out.format("%10.3f", ratings.get(mAllItems[j])); 
                System.out.print(" "); 
                System.out.format("%10d", frequencies.get(mAllItems[j])); 
            } 
        System.out.println(); 
    } 
   
  public static void print(Map<ItemId,Float> user) { 
    for (ItemId j : user.keySet()) { 
      System.out.println(" "+ j+ " --> "+user.get(j).floatValue()); 
    } 
  } 
   
  public void buildDiffMatrix() { 
    mDiffMatrix = new HashMap<ItemId,Map<ItemId,Float>>(); 
    mFreqMatrix = new HashMap<ItemId,Map<ItemId,Integer>>(); 
    // first iterate through users 
    for(Map<ItemId,Float> user : mData.values()) { 
      // then iterate through user data 
      for(Map.Entry<ItemId,Float> entry: user.entrySet()) { 
        if(!mDiffMatrix.containsKey(entry.getKey())) { 
          mDiffMatrix.put(entry.getKey(), new HashMap<ItemId,Float>()); 
          mFreqMatrix.put(entry.getKey(), new HashMap<ItemId,Integer>()); 
        } 
        for(Map.Entry<ItemId,Float> entry2: user.entrySet()) { 
          int oldcount = 0; 
          if(mFreqMatrix.get(entry.getKey()).containsKey(entry2.getKey())) 
            oldcount = mFreqMatrix.get(entry.getKey()).get(entry2.getKey()).intValue(); 
          float olddiff = 0.0f; 
          if(mDiffMatrix.get(entry.getKey()).containsKey(entry2.getKey())) 
            olddiff = mDiffMatrix.get(entry.getKey()).get(entry2.getKey()).floatValue(); 
          float observeddiff = entry.getValue() - entry2.getValue(); 
          mFreqMatrix.get(entry.getKey()).put(entry2.getKey(),oldcount + 1); 
          mDiffMatrix.get(entry.getKey()).put(entry2.getKey(),olddiff+observeddiff);           
        } 
      } 
    } 
    for (ItemId j : mDiffMatrix.keySet()) { 
      for (ItemId i : mDiffMatrix.get(j).keySet()) { 
        float oldvalue = mDiffMatrix.get(j).get(i).floatValue(); 
        int count = mFreqMatrix.get(j).get(i).intValue(); 
        mDiffMatrix.get(j).put(i,oldvalue/count); 
      } 
    } 
  } 
} 
 
class UserId  { 
  String content; 
  public UserId(String s) { 
    content = s; 
  } 
   
  public int hashCode() { return content.hashCode();} 
  public String toString() { return content; } 
} 
class ItemId  { 
  String content; 
  public ItemId(String s) { 
    content = s; 
  } 
  public int hashCode() { return content.hashCode();} 
  public String toString() { return content; } 
} 

Python：

# Copyright 2006 Bryan O'Sullivan <bos@serpentine.com>. 
# 
# This software may be used and distributed according to the terms 
# of the GNU General Public License, version 2 or later, which is 
# incorporated herein by reference. 
 
class SlopeOne(object): 
    def __init__(self): 
        self.diffs = {} 
        self.freqs = {} 
 
    def predict(self, userprefs): 
        preds, freqs = {}, {} 
        for item, rating in userprefs.iteritems(): 
            for diffitem, diffratings in self.diffs.iteritems(): 
                try: 
                    freq = self.freqs[diffitem][item] 
                except KeyError: 
                    continue 
                preds.setdefault(diffitem, 0.0) 
                freqs.setdefault(diffitem, 0) 
                preds[diffitem] += freq * (diffratings[item] + rating) 
                freqs[diffitem] += freq 
        return dict([(item, value / freqs[item]) 
                     for item, value in preds.iteritems() 
                     if item not in userprefs and freqs[item] > 0]) 
 
    def update(self, userdata): 
        for ratings in userdata.itervalues(): 
            for item1, rating1 in ratings.iteritems(): 
                self.freqs.setdefault(item1, {}) 
                self.diffs.setdefault(item1, {}) 
                for item2, rating2 in ratings.iteritems(): 
                    self.freqs[item1].setdefault(item2, 0) 
                    self.diffs[item1].setdefault(item2, 0.0) 
                    self.freqs[item1][item2] += 1 
                    self.diffs[item1][item2] += rating1 - rating2 
        for item1, ratings in self.diffs.iteritems(): 
            for item2 in ratings: 
                ratings[item2] /= self.freqs[item1][item2] 
 
if __name__ == '__main__': 
    userdata = dict( 
        alice=dict(squid=1.0, 
                   cuttlefish=0.5, 
                   octopus=0.2), 
        bob=dict(squid=1.0, 
                 octopus=0.5, 
                 nautilus=0.2), 
        carole=dict(squid=0.2, 
                    octopus=1.0, 
                    cuttlefish=0.4, 
                    nautilus=0.4), 
        dave=dict(cuttlefish=0.9, 
                  octopus=0.4, 
                  nautilus=0.5), 
        ) 
    s = SlopeOne() 
    s.update(userdata) 
    print s.predict(dict(squid=0.4)) 

 =-========================== 延伸文章===========================

来源 ： http://my.donews.com/clickstone/2006/10/16/fktEQWUckzvGDyfjugcqcJjkaDpdjemooGTf/

本文是关于推荐系统的系列研究文章之一，其他内容将陆续发布。这些内容，大多数来自我在2004年底完成的一篇项目方案建议书。放在这里，抛砖引玉，供大家讨论之用。
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

在推荐系统简介中，我们给出了推荐系统的一般框架。很明显，推荐方法是整个推荐系统中最核心、最关键的部分，很大程度上决定了推荐系统性能的优劣。目前，主要的推荐方法包括：基于内容推荐、协同过滤推荐、基于关联规则推荐、基于效用推荐、基于知识推荐和组合推荐。

一、基于内容推荐

基于内容的推荐（Content-based Recommendation）是信息过滤技术的延续与发展，它是建立在项目的内容信息上作出推荐的，而不需要依据用户对项目的评价意见，更多地需要用机 器学习的方法从关于内容的特征描述的事例中得到用户的兴趣资料。在基于内容的推荐系统中，项目或对象是通过相关的特征的属性来定义，系统基于用户评价对象 的特征，学习用户的兴趣，考察用户资料与待预测项目的相匹配程度。用户的资料模型取决于所用学习方法，常用的有决策树、神经网络和基于向量的表示方法等。 基于内容的用户资料是需要有用户的历史数据，用户资料模型可能随着用户的偏好改变而发生变化。

基于内容推荐方法的优点是：
 1）不需要其它用户的数据，没有冷开始问题和稀疏问题。
 2）能为具有特殊兴趣爱好的用户进行推荐。
 3）能推荐新的或不是很流行的项目，没有新项目问题。
 4）通过列出推荐项目的内容特征，可以解释为什么推荐那些项目。
 5）已有比较好的技术，如关于分类学习方面的技术已相当成熟。

缺点是要求内容能容易抽取成有意义的特征，要求特征内容有良好的结构性，并且用户的口味必须能够用内容特征形式来表达，不能显式地得到其它用户的判断情况。

二、协同过滤推荐

协同过滤推荐（Collaborative Filtering Recommendation）技术是推荐系统中应用最早和最为成功的技术之一。它一般采用最近邻技术，利用用户的历史喜好信息计算用户之间的距离，然后 利用目标用户的最近邻居用户对商品评价的加权评价值来预测目标用户对特定商品的喜好程度，系统从而根据这一喜好程度来对目标用户进行推荐。协同过滤最大优 点是对推荐对象没有特殊的要求，能处理非结构化的复杂对象，如音乐、电影。

协同过滤是基于这样的假设：为一用户找到他真正感兴趣的内容的好方法是首先找到与此用户有相似兴趣的其他用户，然后将他们感兴趣的内容推荐给此用 户。其基本思想非常易于理解，在日常生活中，我们往往会利用好朋友的推荐来进行一些选择。协同过滤正是把这一思想运用到电子商务推荐系统中来，基于其他用 户对某一内容的评价来向目标用户进行推荐。

基于协同过滤的推荐系统可以说是从用户的角度来进行相应推荐的，而且是自动的，即用户获得的推荐是系统从购买模式或浏览行为等隐式获得的，不需要用户努力地找到适合自己兴趣的推荐信息，如填写一些调查表格等。

和基于内容的过滤方法相比，协同过滤具有如下的优点：
1） 能够过滤难以进行机器自动内容分析的信息，如艺术品，音乐等。
2） 共享其他人的经验，避免了内容分析的不完全和不精确，并且能够基于一些复杂的，难以表述的概念（如信息质量、个人品味）进行过滤。
3） 有推荐新信息的能力。可以发现内容上完全不相似的信息，用户对推荐信息的内容事先是预料不到的。这也是协同过滤和基于内容的过滤一个较大的差别，基于内容的过滤推荐很多都是用户本来就熟悉的内容，而协同过滤可以发现用户潜在的但自己尚未发现的兴趣偏好。
4） 能够有效的使用其他相似用户的反馈信息，较少用户的反馈量，加快个性化学习的速度。

虽然协同过滤作为一种典型的推荐技术有其相当的应用，但协同过滤仍有许多的问题需要解决。最典型的问题有稀疏问题（Sparsity）和可扩展问题（Scalability）。

三、基于关联规则推荐

基于关联规则的推荐（Association Rule-based Recommendation）是以关联规则为基础，把已购商品作为规则头，规则体为推荐对象。关联规则挖掘可以发现不同商品在销售过程中的相关性，在零 售业中已经得到了成功的应用。管理规则就是在一个交易数据库中统计购买了商品集X的交易中有多大比例的交易同时购买了商品集Y，其直观的意义就是用户在购 买某些商品的时候有多大倾向去购买另外一些商品。比如购买牛奶的同时很多人会同时购买面包。

算法的第一步关联规则的发现最为关键且最耗时，是算法的瓶颈，但可以离线进行。其次，商品名称的同义性问题也是关联规则的一个难点。

四、基于效用推荐

基于效用的推荐（Utility-based Recommendation）是建立在对用户使用项目的效用情况上计算的，其核心问题是怎么样为每一个用户去创建一个效用函数，因此，用户资料模型很大 程度上是由系统所采用的效用函数决定的。基于效用推荐的好处是它能把非产品的属性，如提供商的可靠性（Vendor Reliability）和产品的可得性（Product Availability）等考虑到效用计算中。

五、基于知识推荐

基于知识的推荐（Knowledge-based Recommendation）在某种程度是可以看成是一种推理（Inference）技术，它不是建立在用户需要和偏好基础上推荐的。基于知识的方法因 它们所用的功能知识不同而有明显区别。效用知识（Functional Knowledge）是一种关于一个项目如何满足某一特定用户的知识，因此能解释需要和推荐的关系，所以用户资料可以是任何能支持推理的知识结构，它可以 是用户已经规范化的查询，也可以是一个更详细的用户需要的表示。

六、组合推荐

由于各种推荐方法都有优缺点，所以在实际中，组合推荐（Hybrid Recommendation）经常被采用。研究和应用最多的是内容推荐和协同过滤推荐的组合。最简单的做法就是分别用基于内容的方法和协同过滤推荐方法 去产生一个推荐预测结果，然后用某方法组合其结果。尽管从理论上有很多种推荐组合方法，但在某一具体问题中并不见得都有效，组合推荐一个最重要原则就是通 过组合后要能避免或弥补各自推荐技术的弱点。

在组合方式上，有研究人员提出了七种组合思路：
1）加权（Weight）：加权多种推荐技术结果。
2）变换（Switch）：根据问题背景和实际情况或要求决定变换采用不同的推荐技术。
3）混合（Mixed）：同时采用多种推荐技术给出多种推荐结果为用户提供参考。
4）特征组合（Feature combination）：组合来自不同推荐数据源的特征被另一种推荐算法所采用。
5）层叠（Cascade）：先用一种推荐技术产生一种粗糙的推荐结果，第二种推荐技术在此推荐结果的基础上进一步作出更精确的推荐。
6）特征扩充（Feature augmentation）：一种技术产生附加的特征信息嵌入到另一种推荐技术的特征输入中。
7）元级别（Meta-level）：用一种推荐方法产生的模型作为另一种推荐方法的输入。
七、主要推荐方法的对比

各种推荐方法都有其各自的优点和缺点，见表1。

在此处可以找到原文阐述如何使用此款软件: http://www.senocular.com/flash/tutorials/starumltoas3/

关键安装方式是：

1. 下载 StrarUML http://www.staruml.com/ 。
2. 下载 AS3 代码生成模板  http://www.senocular.com/flash/tutorials/starumltoas3/downloads/StarUML_ActionScript3_Export.zip
3. 进入 StrarUML   所在的安装目录下 \modules\staruml-generator\templates 处将 模板中 ActionScript 3.0 整个文件夹放入到这里。
   最后可以得到如下2个路径： 
   <StarUML 安装目录>\modules\staruml-generator\templates\ActionScript 3.0\template description.tdf
   <StarUML 安装目录>\modules\staruml-generator\templates\ActionScript 3.0\template.cot

关键使用方式：

1. 启动StarUML 并打开你要导出代码的 UML 视图。
2. 选择  Tools > StarUML Generator
3. 勾上 模板列表（list of template）中文档名(Document Name)为 ActionScript 3.0 选项。
4. 点下 next
5. 此时面板会让你选择导出路径。自己选择吧，比如直接可以倒入到 Src中。
6. 选择完毕后点下 next
7. 此时，会等待你决定是否立即产出代码
8. 点Generate 即可。

StarUML AS3例子：
http://www.senocular.com/flash/tutorials/starumltoas3/downloads/Gallery.uml

另外再提供UML学习指南：http://www.uml.org.cn/oobject/OObject.asp

pre {                               /* make the box translucent (80% opaque) */ 
   border: solid red; 
   opacity: 0.8;                    /* Firefox, Safari(WebKit), Opera */ 
   -ms-filter: "alpha(opacity=80)"; /* IE 8 */ 
   filter: alpha(opacity=80);       /* IE 4-7 */ 
   zoom: 1;       /* set "zoom", "width" or "height" to trigger "hasLayout" in IE 7 and lower */  
} 

ref:https://developer.mozilla.org/En/CSS:-moz-opacity

原文地址：http://www.14px.com/?tag=line-height
作者：十四象素

[参与测试的浏览器：IE6 / IE7 / IE8 / FF3 / OP9.6 / SF3 / Chrome2 ]
[操作系统：Windows]

浏览器们缺乏党的教育，对行高没有统一的认识，于是在小字体小行高的情况下，总出现肉眼可见差异，对美观产生了举足轻重的影响。

要解决这一细节性的问题，我们首先得进行一番测试来了解各浏览器对于行高的认识，由于仅小行高和小字体影响比较大，我们就不探究其细节规律（比如字体大小对变化速度的影响规律）了，能在一定程度上解决问题便达到了我们想要的效果。

以下是经过一番头晕眼花的测试后得出的实验数据：

大小	行高	浏览器	宋体		Arial纯中文		Arial带英文字符
			上边距	下边距	上边距	下边距	上边距	下边距
12px	14px	ie6	0px	3px	0px	3px	1px	2px
12px	14px	ie7	1px	2px	0px	3px	1px	2px
12px	14px	ie8	1px	2px	0px	3px	1px	2px
12px	14px	ff3	1px	2px	2px	1px	2px	1px
12px	14px	chrome2	1px	2px	2px	1px	2px	1px
12px	14px	op9.6	1px	2px	1px	2px	1px	2px
12px	14px	sf3	1px	2px	1px	2px	1px	2px
12px	15px	ie6	1px	3px	1px	3px	1px	3px
12px	15px	ie7	2px	2px	1px	3px	1px	3px
12px	15px	ie8	1px	3px	0px	4px	1px	3px
12px	15px	ff3	1px	3px	2px	2px	2px	2px
12px	15px	chrome2	1px	3px	2px	2px	2px	2px
12px	15px	op9.6	1px	3px	1px	3px	1px	3px
12px	15px	sf3	1px	3px	1px	3px	1px	3px
12px	16px	ie6	1px	4px	1px	4px	2px	3px
12px	16px	ie7	2px	3px	1px	4px	2px	3px
12px	16px	ie8	2px	3px	1px	4px	2px	3px
12px	16px	ff3	2px	3px	3px	2px	3px	2px
12px	16px	chrome2	2px	3px	2px	3px	2px	3px
12px	16px	op9.6	2px	3px	2px	3px	2px	3px
12px	16px	sf3	2px	3px	2px	3px	2px	3px
12px	17px	ie6	2px	4px	2px	4px	3px	3px
12px	17px	ie7	3px	3px	2px	4px	3px	3px
12px	17px	ie8	2px	4px	1px	5px	2px	4px
12px	17px	ff3	2px	4px	3px	3px	3px	3px
12px	17px	chrome2	2px	4px	3px	3px	3px	3px
12px	17px	op9.6	2px	4px	2px	4px	2px	4px
12px	17px	sf3	2px	4px	2px	4px	2px	4px

由表可见

1. 需要外观上非常完美的呈现单行文本垂直居中（没有1px的差异），需要设置字体为宋体。

解释：当字体为宋体的时候，各浏览器中上边距和下边距的差异都是较小的，出现问题的仅仅是IE6（行高为偶数时）与IE7（行高为奇数时），而IE6和IE7是可以很容易使用hack来通过padding的多少来精确控制其位置。

示例：

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> 
<html xmlns="http://www.w3.org/1999/xhtml"> 
    <head> 
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> 
        <meta name="author" content="Chomo" /> 
        <link rel="start" href="http://www.14px.com" title="Home" /> 
        <title>line-height非常完美的兼容</title> 
    </head> 
    <style type="text/css"> 
        * {margin:0; padding:0; list-style:none; }  
        div { font-size:12px; font-family:simsun; line-height:15px; float:left; padding:1px 3px; *padding:0 3px 2px 3px; _padding:1px 3px; border:1px solid #000;}  
    </style> 
    <body> 
        <div>十四像素 - 14px</div> 
    </body> 
</html> 

提示：你可以先修改部分代码再运行。

2. 如果确定标签内存在英文字符、数字、符号，可以设置英文字体，利用行高在15px下呈现的状态。

解释：此时仅ff3和chrome2浏览器存在些许差异，并且外观上不存在上多下少的边距。

示例：

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> 
<html xmlns="http://www.w3.org/1999/xhtml"> 
    <head> 
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> 
        <meta name="author" content="Chomo" /> 
        <link rel="start" href="http://www.14px.com" title="Home" /> 
        <title>line-height:15px;font-family:arial时呈现比较理想的状态</title> 
    </head> 
    <style type="text/css"> 
        * {margin:0; padding:0; list-style:none; }  
        div { font-size:12px; font-family:arial; line-height:15px; float:left; padding:1px 3px; border:1px solid #000;}  
    </style> 
    <body> 
        <div>十四像素 - 14px</div> 
    </body> 
</html> 

提示：你可以先修改部分代码再运行。

3. 如果不能保证是否存在英文字符、数字、符号，又需要设置英文字体保证美观，也可利用行高在15px下呈现的状态。（推荐）

解释：此时ie8浏览器下的状态不容乐观，上下差异太大：上0px，下4px，但可以利用:before伪类，赐它一个符号。

示例：

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> 
<html xmlns="http://www.w3.org/1999/xhtml"> 
    <head> 
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> 
        <meta name="author" content="Chomo" /> 
        <link rel="start" href="http://www.14px.com" title="Home" /> 
        <title>line-height:15px;font-family:arial时呈现比较理想的状态（即使是纯中文）</title> 
    </head> 
    <style type="text/css"> 
        * {  
            margin:0;  
            padding:0;  
            list-style:none;  
        }  
        div {  
            font-size:12px;  
            font-family:arial;  
            line-height:15px;  
            float:left;  
            padding:1px 3px;  
            border:1px solid #000;  
        }  
        div:before {  
            content:"1";  
            margin-left:-2000px;  
            margin-right:1993px;  
        }  
    </style> 
    <body> 
        <div>十四像素</div> 
    </body> 
</html> 

提示：你可以先修改部分代码再运行。

Global:

 "AS do AS things (code), JS do JS things (code), only communicate with me (bridge)"

目标：
   “AS做AS的事(code)，JS做JS的事(code)，仅在沟通时用我(bridge)！"

project home :  http://code.google.com/p/ajbridge/

svn:  http://ajbridge.googlecode.com/svn/trunk/