エントロピーモデルを用いて商品価格を決める理論と、Pythonによる実装方法を説明します。
もう少し正確に書くと、複数のカテゴリがある類似の商品において、価格の比を変えることで、需要をコントロールする理論となります。
オペレーションズリサーチという分野でたまに登場します。

いくつかの仮定を満たしている必要はありますが、データがほとんどない状態でも適用できるのが強みです。
Pythonにおける制約付き最適化のプログラミングの方法と合わせて説明をします。AnacondaとJupyter Notebookの利用を前提とします。
数学的に厳密な説明ではなく、ざっくりとした分析の手順を載せてある記事となります。
実行結果はまとめてこちらから参照することができます



スポンサードリンク

目次

  1. エントロピーモデルとは
  2. Pythonで計算する情報エントロピー
  3. 1因子情報路モデル
  4. 1因子情報路モデルの関数化
  5. 層別化:固定層がいる場合の購入割合
  6. 多因子情報路モデル

 

1.エントロピーモデルとは

厳密な議論は避けますが、エントロピーとは「乱雑さ」の度合いであるといわれることがしばしばあります。
エントロピーモデルといっても実はいくつかの種類があります。おおよそ「ある特定の条件下でエントロピーを最大にすることによって、何らかのほしい結果を得る計算手法」だと思えばよろしいかと思います。
これだけでは大雑把すぎて何を指しているのかわからないかと思うので、以下で補足します。

ここでは、情報エントロピーを対象とします。
情報エントロピーの詳細は『情報理論の基礎~情報量の定義から相対エントロピー、相互情報量まで~』を参照してください。
情報エントロピーも同じく「情報エントロピーが大きければ大きいほど、乱雑さが大きい」とみなせる指標です。

ここで、「世の中の現象は放っておいたら、乱雑な状態になるように進んでいく」と考えます。
きれいな部屋も、掃除をしなければ荷物が散らかってしまいます。
コップの中に一滴のインクを垂らすと、最初は1カ所に固まっていたインクの滴がどんどんとコップの中へと広がっていきます。
何も手を加えなければ、どんどんと乱雑な状態(エントロピーが大きな状態)へと移っていく。
一度乱雑な状態(エントロピーが大きな状態)になってしまうと、そのままになってしまう。

こういう風に考えると、この「エントロピーは放っておくと増大する」というのを予測に使えるのではないかというアイデアが出てきます。
「放っておくと、エントロピーが最大になるように状況が変化するはずだ」という想定が正しければ「エントロピーが最大になった状況を予測値として提案する」ことができるはずです。
これが今回紹介するエントロピーモデルの基本的な発想です。

エントロピーモデルを応用した価格決定の理論では、以下のように想定します。
1.商品の購入者は、なるべく安く商品を手に入れたいはずだ
2.購入者は自由にふるまうため、乱雑さ(エントロピー)は大きくなるはずだ

ここで、ほぼ同じ内容で、値段だけが異なる2つの商品があったとします。
例えば、あるゲームの中で使える、2種類の商品券があったとしましょう。共に換金率は変わりません。
商品券Aは1000円で、商品券Bは3000円です。

理屈で考えると3000円の商品券は不要のはずです。1000円の商品券を3枚買っても同じわけですから。もしかしたら商品券を買ったのに使わないで放置してしまうかもしれません。こういったリスクを回避するためにも「安い」商品券Aを多くの人が購入することが想定されます。
しかし、2つの選択肢があったら、あまり効率的で無いとしても、自由に(あるいは乱雑に)ふるまって3000円の商品券を購入する人も出てくるでしょう。じゃあ、どれくらいの割合で商品券Bが購入されるのでしょうか。
そして、新たなる商品券C,D,Eを各々2000円、4000円、5000円で発売したとき、商品券A~Eはどのくらいの割合で売られると予想できるでしょうか。

コンビニなどに商品券を置いてもらう場合は、ある程度需要の予測ができた方が便利ですね。
しかし、過去に2000円や5000円の商品券を売ったことがないというのであれば、統計的学習理論を用いた予測は困難です。
こんなときに、エントロピーモデルが利用できます。

 

2.Pythonで計算する情報エントロピー

情報エントロピーの復習をしつつ、Pythonで情報エントロピーを計算する方法を説明します。
N種類の要素を持つある事象Xの情報エントロピーは以下のようにして計算されます。

$$
平均情報量 : H(X) = \displaystyle \sum_{ i = 1 }^{ N } – P(x_i) \times \log P(x_i) \\
$$

P(x)でxが発生する確率となります。
情報理論では、「発生する確率が小さい現象」が起こったことが判明したときに「情報量が大きい」と判断します。
北海道で雪が降っても”そんなもんか”というところですが、沖縄で雪が降ったら”びっくり!”となりますよね。沖縄で雪が降ったというニュースの方が情報量が大きいわけです。あとは、計算の簡単のため対数を適用し「-log{P(x)}」が情報量となります。頭にマイナスがついているので、確率が小さければ小さいほど、情報量が大きくなります。

次に、乱雑な状況を「何が起こるかよくわからない状況」だと考えてみます。
「何が起こるかわからない」を言い換えると「どんな内容を聞かされても”情報量がある”とみなせてしまう状況」となります。
まったく知らない街に置いてけぼりにされたら、こっちに郵便局があるとか、交番があるとか、駅があるとか、何を聞かされてもうれしいですよね。こんな状況です。逆にすでにある程度知っている街にいる場合は、こっちに郵便局があるだなんて教えてもらってもうれしくないわけです。
ということで「平均的に得られる情報量」すなわち平均情報量が「現象にたいする不確実性」である情報エントロピーとみなせることになるので、情報量の期待値をとって、先のように情報エントロピーが計算されることになります。

ここら辺をもう少し丁寧に説明したのが『情報理論の基礎~情報量の定義から相対エントロピー、相互情報量まで~』ですので、こちらも併せて参照してください。

 

続いて、情報エントロピーをPythonで計算してみます。AnacondaとJupyter Notebookの使用を前提とします。
実行結果はまとめてこちらから参照することができます

まずはライブラリの読み込みです。
科学計算を行う際の標準的なライブラリであるscipyと、ndarrayという便利なデータ形式を持つnumpyをインポートします。

情報エントロピーを計算するために、scipy.statsから、その名もentropyという関数をインポートします。
後ほどエントロピーを最大にする計算を行うので、scipy.optimizeからminimize関数をインポートしておきました。

 
# ライブラリを読み込む
import scipy as sp
import numpy as np

from scipy.optimize import minimize # 最適化
from scipy.stats import entropy     # エントロピー計算

# 表示桁数の設定
%precision 3

 
2つの要素があって、各々80%、20%の確率で発生する場合の情報エントロピーは以下のように計算されます。
定義通り計算したものと、entropy関数を使ったものと2通りの計算方法を載せています。結果は変わりません。
なお、対数の底はネイピア数(およそ2.7)となっているので、情報量の単位はnatとなります。

# エントロピー計算
probs = np.array([0.8, 0.2])

H = -1*probs[0]*sp.log(probs[0]) - probs[1]*sp.log(probs[1])
print('情報エントロピー')
print(H)

print('情報エントロピー(関数使用)')
print(entropy(probs))

 
結果はこちら

情報エントロピー
0.500402423538
情報エントロピー(関数使用)
0.500402423538

 
ところで、これからエントロピーを最大にするように頑張るわけですが、情報エントロピーはどのようなときに最大になるのでしょうか。
2通りの結果がある場合は、各々が50%ずつ起こる場合に、最も情報エントロピーが大きくなります。
見知らぬ街に置いてけぼりにされた時、駅が右の道にあるのが左の道にあるのかわからない、という状況を想像してください。左の道に行くと80%の確率で駅があるとなったらそっちに行けばいいわけです。一番つらいのは、右に行っても左に行っても50%の確率で駅があると思われる状況です。
3通りの結果がある場合は、各々が1/3の確率で発生するときに情報エントロピーが最も大きくなります。

確認します。

# 最も大きなエントロピー
probs = np.array([0.5, 0.5])
entropy(probs)

結果は『0.693』となるので、やはり大きな値になったことがわかります。



スポンサードリンク

 

3.1因子情報路モデル

価格の比と商品の購入割合の関係を調べるというテーマに戻ります。
あるゲームの中で使える、2種類の商品券があったとしましょう。共に換金率は変わりません。
商品券Aは1000円で、商品券Bは3000円です。
各々、どのくらいの割合で購入されるでしょうか。
今回は価格という1つの因子だけを対象とするため、一因子情報路と呼ばれるモデルを使ってこの問題に回答することになります。
複雑化したバージョンは後ほど説明します。

この時、以下の仮定が満たされていると考えます。
1.商品の購入者は、なるべく安く商品を手に入れたいはずだ
2.購入者は自由にふるまうため、乱雑さ(エントロピー)は大きくなるはずだ

というわけで
「購入割合のエントロピー」÷「消費金額の期待値」
が最大になる購入割合を計算します。
こうすることで、エントロピーが大きく(自由にふるまうので乱雑性が大きい)、それでいてある程度合理的な決定を行う(安く商品を手に入れる)という状況下における、商品購入割合が計算されることになります。

なお、「消費金額の期待値」は、俗にいう重み付き平均で計算されるものです。
期待値は「『確率×その時の値』の合計」で計算されます。
すなわち、
「消費金額の期待値」=「商品券A割合×1000 + 商品券B購入割合×3000」
で計算されます。

ところで、商品券AとBの価格の比は1:3ですので、1000で割って、価格を1円と3円にしても一般性を失いません。

というわけで、1因子情報路は以下のコードを実行することで計算結果が得られます。

# 価格の比率
cost_ratio = np.array([1,3])

# 目的関数
def target_func(user_ratio):
    return (float)(-1 * entropy(user_ratio)/(sum(user_ratio * cost_ratio)))

# 制約条件式
# 「0よりも大きい」を表すために、小さな値を足しこんでいる(デフォルトだと0以上の設定)
cons = (
    {'type': 'ineq','fun': lambda p: p[0]},
    {'type': 'ineq','fun': lambda p: p[1]},
    {'type': 'eq',  'fun': lambda p: p[0] + p[1] - 1}
)

# 初期値
p = np.array([0.5,0.5])

# ソルバーを実行
result = minimize(target_func, 
                  x0=p, 
                  constraints=cons, 
                  method="SLSQP",
                  options={'maxiter': 10000, 'ftol': 1e-10})

# 結果の表示
print('エントロピーモデルにより計算された購入比率')
print(result.x)

まずは価格の比を設定しておきます。今回は1:3ですので『cost_ratio = np.array([1,3])』とします。

 
続いて最適化の対象である以下の目的関数を定義します。『target_func』という名前にしておきます。
target_func:「購入割合のエントロピー」÷「消費金額の期待値」

target_funcが最大になる購入割合を調べるわけなので、関数の引数には購入割合(user_ratio)が入ります。
ところで、scipyの最適化関数は、最小化はできるのですが、最大化ができません。そこで、結果にマイナス1をかけて、最大と最小が逆になるようにしています。
またfloatでキャスト(型変換)しています。これをやらないとminimize関数を実行したときにエラーになるので注意してください。

 
購入割合を色々に変化させて、target_funcが最大になる購入割合を探します。しかし「購入割合がマイナス6万」というのはあり得ませんね。割合は0以上であり、かつ合計したら1になる必要があります。そこを指定するのがconsです。
今回は3つの条件を指定しました。
『’type’: ‘ineq’』とした場合は「ある数式が非負(0以上)」という制約条件になります。
制約の対象となる数式は『’fun’: lambda p: p[0]』のようにラムダ式で設定します。2つある購入割合(商品券Aの購入割合と商品券Bの購入割合)が共に0以上となるので、2つとも設定します。

『’type’: ‘eq’』は「ある数式が0と等しい」という制約条件になります。
あくまでも「0と」等しいことに注意が必要です。なので、任意の値と等しいという条件にしたければ、その値を引いてやる必要があります。
というわけで、割合の合計値が1になるという条件は『’fun’: lambda p: p[0] + p[1] – 1』と設定されます。

 
後は初期値を適当に定めてminimize関数を実行するだけです。
対象となる目的関数(target_func)、制約条件(cons)、最適化の方法(method=”SLSQP”)と、オプションをいくつか指定します。
オプションは、計算の精度を上げるために、反復計算の回数などを指定してあります。詳しくはマニュアルを参照してください。

結果は以下のようになります。
=================
エントロピーモデルにより計算された購入比率
[ 0.682 0.318]
=================

1000円の商品券Aの方がやはり多く購入されますが、商品券Bを買う人も3割ほどいるようです。

 

4.1因子情報路モデルの関数化

先ほどのように計算しても良いのですが、商品の種類数が変わると、制約条件などを毎回書き直さなくてはならないので不便です。
そこで、全部まとめて関数にしておきます。
商品の金額比を設定して関数を1つ実行するだけで、理論上の購入割合がすぐに求まるようにしましょう。『entropy_model_one』という関数名にしました。

# エントロピーモデルの1因子情報路モデルの推定
def entropy_model_one(cost_ratio):
    '''
    エントロピーモデルの1因子情報路モデルの推定

    Arguments:

    cost_ratio -- 商品コストの比率。金額の比率や消費時間の比率等。
    
    '''

    # ランクの数
    rank_num = len(cost_ratio)

    # 最適化の目的関数
    target_func = lambda user_ratio: (float)(-1 * entropy(user_ratio)/(sum(user_ratio * cost_ratio)))

    # 制約条件の作成
    construction = []

    # すべての確率が0以上という制約
    for i in range(0, rank_num):
        construction.append({'type': 'ineq','fun': lambda p: p[i]})

    # 確率の合計が1であるという制約
    construction.append({'type': 'eq','fun': lambda p: sum(p) - 1})

    # 初期値
    p0 = np.tile(1/rank_num, rank_num)

    # ソルバーを実行
    result = minimize(fun=target_func, 
                      x0=p0, 
                      constraints=construction, 
                      method="SLSQP",
                      options={'maxiter': 10000, 'ftol': 1e-10})

    return result

やっていることは変わらないので、詳細はコメントを参照してください。

 
まずは動作確認です。
print(entropy_model_one(np.array([1,3])).x)
と実行すると
[ 0.682 0.318]
という計算結果が返ってくるので、正しく動いていそうです。

 
先ほどはコスト比を1:3にしていました。
これを1:6に変えてみます。
print(entropy_model_one(np.array([1,6])).x)
と実行すると
[ 0.778 0.222]
となります。やはり商品Aの購入割合が増えました。しかし、コスト比が2倍良くなったからといって、そこまで極端に増えるわけではないようです。

 
最後に、1000円から5000円まで細かく分けた商品券を購入した場合を見てみます。
print(entropy_model_one(np.array([1,2,3,4,5])).x)
と実行すると
[ 0.509 0.259 0.132 0.067 0.034]
となります。

商品Aの購入割合が少し下がっていますね。新たに作った2000円の商品券に一部を奪われたようです。
こういう計算結果を見ながら、価格を変えていけば、ある程度は需要をコントロールすることができそうです。

実際の商品購入割合と、今回計算された理論上の購入割合が食い違っていることもあるでしょう。
この時、5節以降で説明する方法で、モデルを修正することが可能です。
また「実際の商品購入割合と、今回計算された理論上の購入割合が食い違っている」ということ自体がとても重要な情報となります。
これはすなわち「価格が高くてもなお、それでも購入したいと思わせる何か」があるということなのですから。商品の評価などにも使うことができるでしょう。

 

5.層別化:固定層がいる場合の購入割合

次は固定層がいる場合の購入割合の計算を行います。
例えば、電気料金を決める際、昼と夜とで金額を変えたとします。夜の方を安くしたとします。
それでもなお、昼の方が電気の消費量は大きいでしょう。値段を安くしたからといって、お昼に電気を使わないわけにはいかないからです。
でも、価格を変えることで、多少は昼の需要を夜間に移すことができるようになるかもしれない。

というわけで「どうしてもお昼に電気を使わなくてはならない」という固定層の割合と、「金額が安い時に電気を使おう」と使い分けてくれる変動層を分けたいわけです。
そこでもやはりエントロピー最大化の原理が使われます。

これはPythonで計算をしていきながら、方法を説明します。

まずは、昼の電気料金と夜の電気料金の比が3:1だったとしましょう。
「固定層」がいなかった場合の選択割合は、以前説明した1因子情報路を使って計算できます。

# 価格の比率
cost_ratio = np.array([3,1])
print('価格の比率')
print(cost_ratio)

# 理論上の選択率
user_ratio_by_cost = entropy_model_one(cost_ratio).x
print('金額の比率から求められる、理論上の商品選択率')
print(user_ratio_by_cost)

結果は以下のようになります。
=================
価格の比率
[3 1]
金額の比率から求められる、理論上の商品選択率
[ 0.318 0.682]
=================

しかし、実際の電気利用率を見ると、7:3で昼の方が多く使われていたとします(架空のデータです)。

# 実際の選択率
true_user_ratio = np.array([0.7,0.3])
print('実際の選択率')
print(true_user_ratio)

結果は以下のようになります。
=================
実際の選択率
[ 0.7 0.3]
=================

この時、以下の3つの客層の割合はいかほどになるでしょうか。

  • 昼の固定客
  • 夜の固定客
  • 金額によって行動を変える客

この時もやはりエントロピーが最大になるように、客層割合を決定します。

この時のエントロピーは以下のように計算されます。

 「客層割合から計算されたエントロピー」
+「金額によって行動を変える客の割合」×「金額による選択率から計算されるエントロピー」

イメージとしては、エントロピーを2つ足し合わせた感じです。
これを計算して、最大になるように客層の割合を求めましょう。

Pythonによるコードは以下のようになります。

# 目的関数(エントロピー最大化)
def target_function(p):
    return (float)(-1*(entropy(p) + p[2]*entropy(user_ratio_by_cost)))


# 制約条件:確率は0以上で合計値は1
# 制約条件:実際の選択率と等しくなる
cons = (
    {'type': 'ineq','fun': lambda p: p[0]},
    {'type': 'ineq','fun': lambda p: p[1]},
    {'type': 'ineq','fun': lambda p: p[2]},
    {'type': 'eq',  'fun': lambda p: p[0] + p[1] + p[2] - 1},
    {'type': 'eq',  'fun': lambda p: p[0] + p[2] * user_ratio_by_cost[0] - true_user_ratio[0]}
)

# 初期値
p = np.array([0.7,0.3,0])

# ソルバーを実行
stable_user_ratio = minimize(target_function, 
                             x0=p, 
                             constraints=cons, 
                             method="SLSQP",
                             options={'maxiter': 10000, 'ftol': 1e-10})

print('商品Aの固定層:商品Bの固定層:価格によって購入するものを変える層')
print(stable_user_ratio.x)

目的関数が、客層から計算されたエントロピー(entropy(p))と「金額による選択率から計算されるエントロピー:entropy(user_ratio_by_cost)」の和になっていることに注目してください。
ただし、金額によって行動を変えてくれる人は一部しかいないのでentropy(user_ratio_by_cost)もその割合の分しか加算されません。

制約条件は「確率が0以上で合計が1になる」というものに加えて「実際の選択率と等しくなる」という制約も必要になります。
「昼の利用率」さえ計算できれば「1-『昼の利用率』」で夜の利用率が計算されるので、ここの制約は1つだけで十分です。

他は1因子情報路と同じなので説明は省略します。

結果は以下のようになります。
=================
商品Aの固定層:商品Bの固定層:価格によって購入するものを変える層
[ 0.602 0.09 0.308]
=================

商品Aを「昼間の電気使用」とすると、全体の6割ほどは、昼間の固定層となります。ここは夜間の料金を下げても、昼間にしか電気を使ってくれません。
(ただし、固定層はあくまでも”現在の金額比”の場合における固定層です。夜間の料金がめちゃくちゃに下がったら、ここの固定層も流動するかもしれませんが、そこは想定していません)

 

6.多因子情報路モデル

後はこの応用で、モデルをいくらでも複雑にしていけます。
ただし、モデルが複雑になると、最適化の計算がうまくいかなくなることもあるかもしれません。

この記事の締めくくりとして多因子情報路モデルを解説します。
例えば鈍行電車と特急電車と新幹線では、料金が違うだけでなく、移動にかかる時間も違います。そのため「安く移動したい」という人と「早く移動したい」という人が混ざっていることが想定されます。
この場合は、1因子情報路を複数つなげた多因子情報路というモデルを構築します。

多因子情報路では、まずは1因子情報路のモデルを用いて、以下を計算します

  • 価格に基づく選択率
  • 所要時間に基づく選択率

そのうえで、以下の割合(以下では客層割合と呼びます)を求めます。

  • 鈍行利用の固定客
  • 特急利用の固定客
  • 新幹線利用の固定客
  • 金額によって行動を変える客
  • 所要時間によって行動を変える客

客層割合は、以下で計算されるエントロピーの和が最大になるように選ばれます。

 「客層割合から計算されたエントロピー」
+「金額によって行動を変える客の割合」×「金額に基づく選択率から計算されるエントロピー」
+「所要時間によって行動を変える客の割合」×「所要時間に基づく選択率から計算されるエントロピー」

 
やってみます。まずは、1因子情報路を用いて「価格に基づく選択率」と「所要時間に基づく選択率」を計算します。
なお、金額の比や所要時間の比、実際の選択率は、架空の値です。

# 価格の比率
cost_ratio = np.array([1,2,4])
print('価格の比率')
print(cost_ratio)

# 所要時間の比率
time_ratio = np.array([8,3,1])
print('所要時間の比率')
print(time_ratio)

# 価格の比率に基づく理論上の選択率
user_ratio_by_cost = entropy_model_one(cost_ratio).x
print('価格の比率に基づく理論上の選択率')
print(user_ratio_by_cost)

# 所要時間の比率に基づく理論上の選択率(無理やり並び替えた)
user_ratio_by_time = entropy_model_one(time_ratio).x
print('所要時間の比率に基づく理論上の選択率')
print(user_ratio_by_time)

# 実際の選択率
true_user_ratio = np.array([0.1,0.4,0.5])
print('実際の選択率')
print(true_user_ratio)

結果は以下のようになります。
=================
価格の比率
[1 2 4]
所要時間の比率
[8 3 1]
価格の比率に基づく理論上の選択率
[ 0.57 0.325 0.105]
所要時間の比率に基づく理論上の選択率
[ 0.039 0.295 0.666]
実際の選択率
[ 0.1 0.4 0.5]
=================

 
そして、実際の選択率と等しくなるという制約条件を満たしつつ、エントロピーが最大になる”客層割合”を求めます。

# 目的関数(エントロピー最大化)
def target_function(p):
    return (float)(-1*(entropy(p) + p[3]*entropy(user_ratio_by_cost) + p[4]*entropy(user_ratio_by_time)))

# 制約条件:実際の選択率と等しくなる
cons = (
    {'type': 'ineq','fun': lambda p: p[0]},
    {'type': 'ineq','fun': lambda p: p[1]},
    {'type': 'ineq','fun': lambda p: p[2]},
    {'type': 'ineq','fun': lambda p: p[3]},
    {'type': 'ineq','fun': lambda p: p[4]},
    {'type': 'eq',  'fun': lambda p: p[0] + p[1] + p[2] + p[3] + p[4] - 1},
    {'type': 'eq',  'fun': lambda p: p[0] + p[3]*user_ratio_by_cost[0] + p[4]*user_ratio_by_time[0] - true_user_ratio[0]},
    {'type': 'eq',  'fun': lambda p: p[1] + p[3]*user_ratio_by_cost[1] + p[4]*user_ratio_by_time[1] - true_user_ratio[1]}
)

# 初期値
p0 = np.array([0.5,0.3,0.2,0,0])

# ソルバーを実行
user_pattern_ratio = minimize(target_function, 
                              x0=p0, 
                              constraints=cons, 
                              method="SLSQP",
                              options={'maxiter': 10000, 'ftol': 1e-10})

print('商品Aの固定層:商品Bの固定層:商品Cの固定層:価格によって変える層:消費時間によって変える層')
print(user_pattern_ratio.x)

結果は以下のようになります。
=================
商品Aの固定層:商品Bの固定層:商品Cの固定層:価格によって変える層:消費時間によって変える層
[ 0.015 0.237 0.209 0.121 0.418]
=================
商品A:鈍行
商品B:特急
商品C:新幹線
というストーリでしたので、鈍行の固定客はほとんどおらず、特急の固定客は24%ほどいるようです。新幹線の固定客は21%ほどですね。
価格を気にする人よりも、所要時間を気にする人の方が多いようです(各々12%と42%)。

エントロピーモデルのような方式は、データをあまり必要としないので適用が簡単ですが、うまくモデルが当てはまっていることのチェックがしにくいという欠点があります。
できればアンケート調査などをして、しっかりとデータをとるべきだと思います。
しかし、ビッグデータが流行語になってから長くたちますが、必要なデータこそが無いということはしばしばあるものです。様々な分析のいわば補佐的な役割として、こういった簡便なモデルが活用できるかもしれません。

誤り等あれば、メールやコメントなどでご指摘いただけますと大変幸いです。

 

参考文献


エントロピー・モデル(ORライブラリー〈14〉)

 
主にこの本を読んでエントロピーモデルの勉強をしました。
数学的な理論に興味がある方は、こちらも読まれるようにしてください。
なお、この本では解析的に解を得ているので、この記事の関数を使って計算した結果とわずかに異なるようです。
 
書籍以外の参考文献

非線形最適化関数|機械学習の Python との出会い
 →Scipyの最適化関数の説明が載っています。

scipy.optimize.minimize
 →Scipyのドキュメントです。



スポンサードリンク

 
更新履歴
2018年07月07日:新規作成