Préface

Articles précédents

Introduction d'une bibliothèque pour traiter la théorie de l'information intégrée et un exemple d'utilisation simple

Il existe une théorie de l'information intégrée qui calcule et quantifie le degré de «conscience» d'un réseau à une valeur de Φ.

Nous examinerons la méthode de calcul de Φ en nous référant au document officiel de PyPhi, une bibliothèque qui gère la théorie de l'information intégrée.

C'est un calcul assez compliqué, je vais donc l'omettre de différentes manières. Pour ceux qui veulent lire l'article original,

Document officiel

Calculating φ

Voir l'article ci-dessus. Il comprend également l'histoire du précédent article deux que j'ai écrit. Je vais.

Je fais juste une traduction approximative en japonais avec des connaissances insuffisantes, je serais donc reconnaissant si un expert le faisait remarquer.

Ceux qui veulent le lire correctement devraient le lire en le comparant avec le matériel officiel de la diapositive Calculating φ. pense.

Réseau et TPM (matrice de probabilité de transition)

Considérons un réseau composé de ces trois éléments, OR, AND et XOR.

Chaque élément de A, B et C a un élément ON ou OFF à l'instant $ t $, et des entrées et sorties vers l'élément connecté. Le résultat change l'état au temps $ t + 1 $.

Puisqu'il est composé de OU, ET et XOR, le tableau suivant peut être créé en prenant l'état du temps $ t $ dans le sens des lignes et l'état du temps $ t + 1 $ dans le sens des colonnes.

t	\	t+1
			A	0	1	0	1	0	1	0	1
			B	0	0	1	1	0	0	1	1
			C	0	0	0	0	1	1	1	1
A	B	C		↑	↑	↑	↑	↑	↑	↑	↑
0	0	0	→	1	0	0	0	0	0	0	0
1	0	0	→	0	0	0	0	1	0	0	0
0	1	0	→	0	0	0	0	0	1	0	0
1	1	0	→	0	1	0	0	0	0	0	0
0	0	1	→	0	1	0	0	0	0	0	0
1	0	1	→	0	0	0	0	0	0	0	1
0	1	1	→	0	0	0	0	0	1	0	0
1	1	1	→	0	0	0	1	0	0	0	0

Dans ce tableau, par exemple, si $ t $ est $ (0, 1, 1) $, la probabilité de devenir $ (1, 0, 1) $ à $ t + 1 $ est de 1 $.

Cette table est appelée TPM (Transition Probability Matrix).

Répertoires d'effets?

Pensons à diverses combinaisons des trois éléments A, B et C, telles que «seul A est retiré», «seul AB est retiré» et «seul BC est retiré».

Comme prémisse du calcul effectué à partir d'ici, on suppose que $ (A, B, C) = (1, 0, 0) $ est fixe.

Tout d'abord, examinons "$ (B, C) $ dans $ t + 1 $ pour $ t $ état $ (A, B, C) $".

En réduisant les informations de A en $ t + 1 $ du tableau précédent, on peut écrire le tableau suivant.

t	\	t+1
			B	0	1	0	1
			C	0	0	1	1
A	B	C
0	0	0		1	0	0	0
1	0	0		0	0	1	0
0	1	0		0	0	1	0
1	1	0		1	0	0	0
0	0	1		1	0	0	0
1	0	1		0	0	0	1
0	1	1		0	0	1	0
1	1	1		0	1	0	0

Surtout quand $ (A, B, C) = (1, 0, 0) $


B	0	1	0	1
C	0	0	1	1

	0	0	1	0

Vous pouvez voir que la probabilité que $ (B, C) = (0, 1) $ soit 1.

De même, si vous regardez "$ (B, C) $ dans $ t + 1 $ pour l'état $ (C) $ dans $ t $"

\|
	B	0	1	0
	C	0	0	1
C
0		1/2	0	1/2
1		1/4	1/4	1/4

Il ressemblera à ceci.

Surtout au $ (1, 0, 0) $ actuellement fixé


B	0	1	0	1
C	0	0	1	1

	1/2	0	1/2	0

La table est créée.

De plus, faisons une table de "$ (A) $ dans $ t + 1 $ pour l'état $ (\ varnothing) $ (indépendant de quoi que ce soit) dans $ t $".


A	0	1

	1/4	3/4

Ces tables ainsi créées sont appelées répertoire d'effets.

Vous pouvez également calculer le répertoire d'effets global en multipliant les tables que vous avez créées précédemment.


A	0	1	0	1	0	1	0
B	0	0	1	1	0	0	1
C	0	0	0	0	1	1	1

	1/8	3/8	0	0	1/8	3/8	0

Cause répertoire?

Nous avons vu précédemment l'effet Repertoire, qui est l'effet de $ t $ sur $ t + 1 $.

Ensuite, regardons l'effet de $ t-1 $ sur $ t $.

Jetons un œil à "$ (B, C) $ dans $ t-1 $ pour l'état $ (C) $ dans $ t $".


		C	0	1
B	C
0	0		1/2	1/2
1	0		1/2	1/2
0	1		1/2	1/2
1	1		1/2	1/2

Surtout à l'état fixe $ (1, 0, 0) $ cette fois


B	C
0	0	1/4
1	0	1/4
0	1	1/4
1	1	1/4

Je peux le trouver. (Standardisé à un total de 1)

Cela signifie que $ B et C $ pour que $ C $ soit égal à 0 peuvent être dans n'importe quel état de la même manière.

Trouvons aussi "$ (A) $ dans $ t-1 $ pour l'état $ (\ varnothing) $ (état indépendant) dans $ t $".


A
0		1/2
1		1/2

Maintenant ça.

Comme précédemment, multiplions les deux tableaux.

$ = $


A	B	C
0	0	0	1/8
1	0	0	1/8
0	1	0	1/8
1	1	0	1/8
0	0	1	1/8
1	0	1	1/8
0	1	1	1/8
1	1	1	1/8

J'ai pu calculer comme ça.

irréductibilité?

Comme précédemment, jetons un œil au répertoire d'effets de $ (A, B, C) $ pour $ (A, C) $.


		A	0	1	0	1	0	1	0	1
		B	0	0	1	1	0	0	1	1
		C	0	0	0	0	1	1	1	1
A	C
1	0		1/4	1/4	0	0	1/4	1/4	0	0

Ce répertoire

{AC\over ABC}

Il est exprimé comme. Démontez ceci

{AC\over AB} \times {\varnothing \over C}

Faisons-le sous la forme de.

Tout d'abord, regardons $ (A, B) $ pour $ (A, C) $.


		A	0	1	0	1
		B	0	0	1	1
A	C
1	0		1/2	1/2	0	0

De plus, jetez un œil à $ C $ pour $ \ varnothing $ (non spécifié).


C	0	1	0

		1/2	1/2

$ (A, B) $ pour $ (A, C) $, $ C $ pour $ \ varnothing $ (non spécifié), le produit de ces deux tables est $ (A) pour $ (A, C) $ , B, C) Correspond à la table $.

{AC \ over ABC} et {AC \ over AB} \ times {\ varnothing \ over C} correspondent.

Il existe de nombreuses façons de prendre une combinaison qui se divise ainsi. Énumérons-les ci-dessous.

{\varnothing \over A}\times {AC\over BC}, {\varnothing \over B}\times {AC\over AC}, {\varnothing \over C}\times {AC\over AB}

{\varnothing \over AB}\times {AC\over C}, {\varnothing \over BC}\times {AC\over A}, {\varnothing \over AC}\times {AC\over B}

{\varnothing \over ABC}\times {AC\over \varnothing}, {A \over \varnothing}\times {C\over ABC}, {A \over A}\times {C\over BC}

{A \over B}\times {C\over AC}, {A \over AB}\times {C\over C}, {A \over C}\times {C\over BC}

{A \over BC}\times {C\over A}, {A \over ABC}\times {C\over \varnothing}

Trouvez le répertoire de causes pour ce délimiteur ** all ** et comparez-le avec l'original $ {AC \ over ABC} $.

La division qui minimise l'écart par rapport à la valeur d'origine est évaluée comme MIP (partition d'information minimale), et l'écart à ce moment-là est évalué comme $ φ $ (petit phi). Dans ce cas, $ {AC \ over AB} \ times {\ varnothing \ over C} $ se délimite à $$ φ = 0 $, qui est le MIP.

Répertoire de cause à effet irréductible au maximum (répertoire de cause à effet irréductible maximal)

ABC\over ABC

Calculons $ φ $ de diverses acquisitions à partir du répertoire d'effets.

Le MIP pour $ ABC \ over A $ est $ {A \ over \ varnothing} \ times {BC \ over A} $, et $ φ = 0 $. Le MIP pour $ ABC \ over B $ est $ {A \ over \ varnothing} \ times {BC \ over B} $, et $ φ = 0 $. Le MIP pour $ ABC \ over C $ est $ {C \ over \ varnothing} \ times {AB \ over C} $, et $ φ = 0 $. Le MIP pour $ ABC \ over AB $ est $ {A \ over \ varnothing} \ times {BC \ over AB} $, soit $ φ = 0,5 $. Le MIP pour $ ABC \ over AC $ est $ {\ varnothing \ over C} \ times {ABC \ over A} $, et $ φ = 0 $. Le MIP pour $ ABC \ over BC $ est $ {AB \ over C} \ times {C \ over B} $, et $ φ = 0,25 $.

Parmi ceux-ci, $ ABC \ sur AB $ a le $ φ_ \ mathrm {effet} ^ {\ mathrm {max}} $ le plus élevé. C'est ce qu'on appelle le répertoire d'effets réductibles Maximumly-ir.

Faire le même calcul Vous pouvez également trouver $ φ_ \ mathrm {cause} ^ {\ mathrm {max}} $ pour cause-repertoire.

φ_\mathrm{cause}^{\mathrm{max} } ,

φ_\mathrm{effect}^{\mathrm{max} }

Le plus petit des deux est adopté comme $ φ $ du champ d'application (intervalle) $ ABC $.

Calculons cela pour $ A, B, C, AB, BC, ABC $.

	A	B	C	AB	BC	ABC
φ_\mathrm{cause}^{\mathrm{max} }	0.17	0.17	0.50	0.25	0.33	0.50
φ_\mathrm{effect}^{\mathrm{max} }	0.25	0.25	0.25	0.50	0.50	0.50
φ	0.17	0.17	0.25	0.25	0.33	0.50

Coupures du système

Jusqu'à présent, nous avons calculé le degré d'irréductibilité de chaque sous-structure.

Mais que pensez-vous du système dans son ensemble?

Introduisons ici le concept de coupe.

Il coupe le chemin "sortie" de "l'élément A" constitué du circuit OU.

Désormais, la valeur de $ A $ n'a aucun impact externe. À ce stade, notez que la valeur de A n'est pas traitée comme «0» mais comme «bruit». Notez également que la route reliant B, C "de" A est active.

Tout d'abord, examinons le TPM de ($ A, B, C ) à ( A $). C'est un circuit OR ordinaire comme auparavant.


			A(OR)	0	1
A	B	C
0	0	0		1	0
1	0	0		1	0
0	1	0		0	1
1	1	0		0	1
0	0	1		0	1
1	0	1		0	1
0	1	1		0	1
1	1	1		0	1

Ensuite, regardons le TPM de ($ A, B, C ) à ( B $). B est un circuit ET, mais la valeur de A est "bruit", et pour B il change quand il devient une valeur aléatoire.


			B(AND)	0	1
A	B	C
0	0	0		1	0
1	0	0		1	0
0	1	0		1	0
1	1	0		1	0
0	0	1		1/2	1/2
1	0	1		1/2	1/2
0	1	1		1/2	1/2
1	1	1		1/2	1/2

B ne peut pas déterminer si la valeur de $ (A, C) $ est $ (0, 1) $ ou $ (1, 1) $ car l'itinéraire est interrompu. Par conséquent, la valeur change avec une probabilité de 1/2.

De même, trouvez C.


			C(XOR)	0	1
A	B	C
0	0	0		1/2	1/2
1	0	0		1/2	1/2
0	1	0		1/2	1/2
1	1	0		1/2	1/2
0	0	1		1/2	1/2
1	0	1		1/2	1/2
0	1	1		1/2	1/2
1	1	1		1/2	1/2

Comme il est XOR, il ne peut être jugé que si la valeur de A est décidée.

Maintenant, multiplions les trois tableaux obtenus jusqu'à présent.

t	\	t+1
			A	0	1	0	1	0	1	0	1
			B	0	0	1	1	0	0	1	1
			C	0	0	0	0	1	1	1	1
A	B	C
0	0	0		1/2	0	0	0	1/2	0	0	0
1	0	0		1/2	0	0	0	1/2	0	0	0
0	1	0		0	1/2	0	0	0	1/2	0	0
1	1	0		0	1/2	0	0	0	1/2	0	0
0	0	1		0	1/4	0	1/4	0	1/4	0	1/4
1	0	1		0	1/4	0	1/4	0	1/4	0	1/4
0	1	1		0	1/4	0	1/4	0	1/4	0	1/4
1	1	1		0	1/4	0	1/4	0	1/4	0	1/4

C'est le "TPM qui coupe l'itinéraire de A à B et C".

Il est important de savoir comment le réseau déconnecté a changé par rapport au TPM du réseau non déconnecté.

Calculons big-Phi

Calculons à nouveau le répertoire de cause à effet réductible Maximum-ir sur la base de ce TPM.

Recalculons la plage que nous avons calculée précédemment ... et ...

Seul le répertoire de cause à effet Maximum irréductible pour $ B $ a changé. Lors du calcul de l'erreur TPM pour chaque cause à effet avec et sans déconnexion, il y avait une différence de 0,17 $.

De plus, ce n’est pas la fin. Cause-effet irréductible au maximum La plage restante $ A, C, AB, BC, ABC $ où le répertoire n'a pas changé est comparée au TPM dans la plage $ \ varnothing $ (non spécifié) lors de la découpe. Je vais. Il y avait une différence de 0,583 $, 1, 1, 1,25, 2 $ dans chaque valeur.

Multipliez ces différences par la valeur $ φ $ de chaque plage et additionnez-les.

	A	B	C	AB	BC	ABC
Différence de TPM par rapport à lui-même	0	0.17	0	0	0	0
intervalle\varnothingDifférence TPM avec	0.583		1	1	1.25	2
φ	0.17	0.17	0.50	0.25	0.33	0.50
Avec la différence (soit)φValeur multipliée par	0.097	0.289	0.25	0.25	0.4125	1

Les dernières colonnes du tableau totalisent $ = 2,0416 $. Il s'agit de la valeur appelée information conceptuelle intégrée, $ Φ $ (grand phi).

Il s'agit de la valeur lorsque «l'itinéraire de A» est coupé, mais «l'itinéraire de B», «l'itinéraire de C», «l'itinéraire de AB», «l'itinéraire de BC» et «l'itinéraire de AC» sont coupés. Si vous le faites, $ Φ $ sera calculé séparément.

Les valeurs calculées sont indiquées dans le tableau.

Route source pour se déconnecter	A	BC	B	AC	C	AB
Φ	2.042	1.924	2.042	1.924	1.972	1.917

La valeur avec le plus petit $ Φ $ de ces valeurs est $ Φ $ pour l'ensemble du système, et le délimiteur à ce moment est MIP (minimum). C'est ce qu'on appelle la partition d'information). Dans ce cas, il semble que MIP doit se déconnecter en fonction d'AB.

Par conséquent, la valeur indiquant la capacité d'intégration d'information de $ ABC $ s'est avérée être $ Φ = 1,917 $.

Calculons avec la bibliothèque

Calculons cette valeur avec une bibliothèque appelée pyphi. Le code de article précédent est juste collé, donc s'il vous plaît voir cela pour l'explication du côté code (bien que ce soit un peu).

Tout d'abord, écrivez le TPM (le format est différent, mais le contenu est le même), décrivez la connexion réseau et créez la classe pyphi.Network () ...

import pyphi
import numpy as np
tpm = np.array([
     [0, 0, 0],
     [0, 0, 1],
     [1, 0, 1],
     [1, 0, 0],
     [1, 0, 0],
     [1, 1, 1],
     [1, 0, 1],
     [1, 1, 0]
 ])
cm = np.array([
     [0, 1, 1],
     [1, 0, 1],
     [1, 1, 0]
 ])
labels = ('A', 'B', 'C')
#Dans ce cas, cm peut être omis
network = pyphi.Network(tpm, cm=cm, node_labels=labels)

Définir l'état initial de ABC (1, 0, 0) ...

state = (1, 0, 0)

Définir l'objectif de calcul ...

subsystem = pyphi.Subsystem(network, state)

Calculer.

pyphi.compute.phi(subsystem)
# 1.916665

Des résultats similaires ont été obtenus.

Source de référence

Fondamentalement, il est traduit en japonais selon le contenu des articles suivants. Si vous voulez le voir un peu plus, veuillez lire ici. Cet article contient trop de concepts à ignorer.

https://journals.plos.org/ploscompbiol/article/file?id=10.1371/journal.pcbi.1006343.s001&type=supplementary

Le document officiel de pyphi est ci-dessous.

https://pyphi.readthedocs.io/

Je vous serais très reconnaissant de bien vouloir souligner certains points. L'article était trop long et c'était l'enfer. Plus de 200 pages du matériel original de la diapositive étaient ridicules.

t	\	t+1
			A	0	1	0	1	0	1	0	1
			B	0	0	1	1	0	0	1	1
			C	0	0	0	0	1	1	1	1
A	B	C		↑	↑	↑	↑	↑	↑	↑	↑
0	0	0	→	1	0	0	0	0	0	0	0
1	0	0	→	0	0	0	0	1	0	0	0
0	1	0	→	0	0	0	0	0	1	0	0
1	1	0	→	0	1	0	0	0	0	0	0
0	0	1	→	0	1	0	0	0	0	0	0
1	0	1	→	0	0	0	0	0	0	0	1
0	1	1	→	0	0	0	0	0	1	0	0
1	1	1	→	0	0	0	1	0	0	0	0

t	\	t+1
			B	0	1	0	1
			C	0	0	1	1
A	B	C
0	0	0		1	0	0	0
1	0	0		0	0	1	0
0	1	0		0	0	1	0
1	1	0		1	0	0	0
0	0	1		1	0	0	0
1	0	1		0	0	0	1
0	1	1		0	0	1	0
1	1	1		0	1	0	0

t	\	t+1
			A	0	1	0	1	0	1	0	1
			B	0	0	1	1	0	0	1	1
			C	0	0	0	0	1	1	1	1
A	B	C
0	0	0		1/2	0	0	0	1/2	0	0	0
1	0	0		1/2	0	0	0	1/2	0	0	0
0	1	0		0	1/2	0	0	0	1/2	0	0
1	1	0		0	1/2	0	0	0	1/2	0	0
0	0	1		0	1/4	0	1/4	0	1/4	0	1/4
1	0	1		0	1/4	0	1/4	0	1/4	0	1/4
0	1	1		0	1/4	0	1/4	0	1/4	0	1/4
1	1	1		0	1/4	0	1/4	0	1/4	0	1/4

t	\	t+1
			A	0	1	0	1	0	1	0	1
			B	0	0	1	1	0	0	1	1
			C	0	0	0	0	1	1	1	1
A	B	C		↑	↑	↑	↑	↑	↑	↑	↑
0	0	0	→	1	0	0	0	0	0	0	0
1	0	0	→	0	0	0	0	1	0	0	0
0	1	0	→	0	0	0	0	0	1	0	0
1	1	0	→	0	1	0	0	0	0	0	0
0	0	1	→	0	1	0	0	0	0	0	0
1	0	1	→	0	0	0	0	0	0	0	1
0	1	1	→	0	0	0	0	0	1	0	0
1	1	1	→	0	0	0	1	0	0	0	0

t	\	t+1
			B	0	1	0	1
			C	0	0	1	1
A	B	C
0	0	0		1	0	0	0
1	0	0		0	0	1	0
0	1	0		0	0	1	0
1	1	0		1	0	0	0
0	0	1		1	0	0	0
1	0	1		0	0	0	1
0	1	1		0	0	1	0
1	1	1		0	1	0	0

t	\	t+1
			A	0	1	0	1	0	1	0	1
			B	0	0	1	1	0	0	1	1
			C	0	0	0	0	1	1	1	1
A	B	C
0	0	0		1/2	0	0	0	1/2	0	0	0
1	0	0		1/2	0	0	0	1/2	0	0	0
0	1	0		0	1/2	0	0	0	1/2	0	0
1	1	0		0	1/2	0	0	0	1/2	0	0
0	0	1		0	1/4	0	1/4	0	1/4	0	1/4
1	0	1		0	1/4	0	1/4	0	1/4	0	1/4
0	1	1		0	1/4	0	1/4	0	1/4	0	1/4
1	1	1		0	1/4	0	1/4	0	1/4	0	1/4

[PYTHON] Quantification de la "conscience" en théorie de l'information intégrée (IIT3.0), méthode de calcul de Φ