  |
はてなキーワード:defとは
高市早苗氏が首相に選出され台湾発言で物議をかもしてから、これまで以上に政治的な議論がなされるように感じる。またただの党派性の選好がどうこうにとどまらず具体的な安全保障まで真剣な意見が交わされるようになったことは、日本社会自体が一つの転換点を迎えているように思える。
そのなかで、個人的に党派の煽りあいや中傷を超えて道具的に政治を語るのに役立つかもしれない一つのネタを紹介したい。あくまでも仮説が、情勢について語る一つの視点になれば幸いである。
なお事前に予測した方向性と合致したためAIの手を大いに借りてある。
また曖昧戦略の欠如は相手の意思決定を手助けするだろう。デマなどについて聞いてみても面白いと思う。
以下perplexityより
自由エネルギー原理の見地から見て、政治の党派性における右派、左派はそれぞれエントロピーの減少における役割の相違という観点から説明できる？
自由エネルギー原理から見た政治の党派性：右派・左派とエントロピー減少の役割の相違
自由エネルギー原理（Free Energy Principle,FEP）の枠組みから政治イデオロギーの左右の違いを説明することは、一定の理論的根拠を持つ興味深い視点を提供します。ただし、これは直接的な学術的応用というより、理論的な仮説として理解されるべきものです。
自由エネルギー原理によれば、すべての生物システムは熱力学の第二法則に対抗してエントロピー増加を最小化することで、秩序を維持しています。具体的には、生物は予測エラーを最小化することで、感覚状態のエントロピー（無秩序さ）を減少させ、環境との相互作用をコントロールします。このプロセスは、**予測処理（predictiveprocessing）**メカニズムを通じて実現されます。つまり、生物は内部モデルを持ち、それに基づいて世界を予測し、実際の入力との差分（予測誤差）を最小化することで、驚き（サプライズ）を制御します。
最近の認知神経科学の研究により、保守主義と進歩主義は予測処理の異なる戦略に対応している可能性が示唆されています。
曖昧性と不確実性に対してより高い耐性を持つ
前帯状皮質（anterior cingulatecortex）の活動が強く、反応競合に対する神経認知的感受性が高い
これらの特性は、高いエントロピー状態（高い不確実性）を許容しながら、情報環境の変化に応じて予測モデルを継続的に更新する戦略に対応しています。自由エネルギー原理の観点からすれば、彼らは予測精度（precision）の重み付けを比較的低く保つことで、新規情報による予測誤差を柔軟に受け入れ、より適応的なモデル更新を可能にしています。
不確実性や曖昧性への耐性が低い
脅威や秩序の乱れに対してより敏感で、知覚的堅性が高い
右扁桃体（right amygdala）の活動が強く、脅威認知に敏感
これらの特性は、予測の確実性（certainty）を高く保ち、既存モデルへの信仰度（prior belief）を強化する戦略に対応しています。自由エネルギー原理の用語では、彼らは予測精度の重み付けを高く設定することで、外界の変化に対して強力な内部モデルの安定性を維持しようとしています。
政治の党派性をエントロピー減少の枠組みで理解すると、以下のような対比が浮かび上がります：
保守主義は、社会的秩序を既存の伝統的制度や階級構造の維持を通じて最小化しようとします。このアプローチは、複雑な社会システムの不確実性を、階層的で確定的な構造によって「切り詰める」戦略です。社会に内在するカオス（高エントロピー）に対抗するため、既に証明された秩序パターン（伝統）を維持することで、予測可能性を確保します。
進歩主義は、社会的秩序を個人の自由、多様性の認容、制度的革新を通じて最小化しようとします。一見すると秩序を緩和しているように見えますが、実際にはより複雑で適応的な秩序化メカニズムを導入することで、社会システムのエントロピーを減少させる戦略です。異なる視点を統合し、新しい情報に基づいて制度を改革することで、社会システムの予測モデルをより現実に適応させようとしています。
不確実性耐性と脳レベルの同期
興味深いことに、研究では不確実性への耐性が低い人ほど、政治的に同じ立場の人たちとの脳活動の同期が強いことが示されています。言い換えれば、不確実性を避けたい個人は、同じイデオロギーの人々と同じ予測モデルを共有することで、集団レベルでのエントロピーを減少させようとしているのです。これは社会的な「外界の秩序化」メカニズムとして機能しています。
最新の複雑システム理論では、政治分極化は正のフィードバックループと相転移（phase transitions）のメカニズムを通じて発生することが示されています。保守主義者は秩序の維持を目指し、進歩主義者は秩序の革新を目指すという相反する動力が、社会システム全体のダイナミクスを決定しています。両者の相互作用は、社会的エントロピーを管理するための補完的なメカニズムとして機能しているとも解釈できます。
この自由エネルギー原理に基づく解釈には重要な限界があります。第一に、個人の認知的特性と政治的立場の関係は因果的ではなく相関的である可能性が高いです。第二に、政治イデオロギーはきわめて文化的・歴史的に構築されたものであり、普遍的な神経生物学的基盤のみでは説明できません。第三に、FEPは主に個体レベルの生物システムを想定しており、社会システムへの直接的な応用には理論的な拡張が必要です。
要するに、自由エネルギー原理の観点から見ると、右派は予測モデルの安定性重視によって秩序を維持するエントロピー減少戦略を採る一方、左派は予測モデルの柔軟性重視によってシステムの適応性を高めるエントロピー減少戦略を採ると理解できます。両者は、相異なるメカニズムを通じて社会的エントロピーの増加に対抗しているのであり、政治的党派性の根底には、不確実性に対する根本的に異なるアプローチが存在していると言えるでしょう。
自由エネルギー原理（FEP）を政治党派性に適用する理論を拡張するには、階層的ベイズ推論の多層構造、社会的相互作用の動的モデル化、経験的検証メカニズムの導入が鍵となります。これにより、個体レベルの神経メカニズムを社会システムレベルへ橋渡しできます。
FEPの核心は階層的予測処理です。個人レベルでは、低次層（感覚入力）が上位層（信念・イデオロギー）の予測を修正しますが、社会レベルでは個人の予測モデルが集団的「事前分布（priors）」を形成します。
右派の階層戦略: 上位層の伝統的priors（家族・国家・宗教）を強く固定し、下位層の変動（社会的変化）を抑制。集団レベルでは「社会的扁桃体機能」として、逸脱者を排除する規範執行メカニズムが働きます。
左派の階層戦略: 上位層のpriorsを動的に更新し、多様な下位層入力（マイノリティ視点）を統合。集団レベルでは「社会的ACC機能」として、対立する予測モデルの調停役を担います。
この拡張により、**党派性は「階層的自由エネルギー最小化の多重均衡状態」**としてモデル化可能。右派は安定均衡（低変動）、左派は適応均衡（高変動）を志向します。
FEPを非平衡動的システム論と統合し、政治分極化を予測誤差駆動の相転移現象として捉えます。
右派アトラクター: 高精度priors → 秩序維持 → 低エントロピー均衡
左派アトラクター: 低精度priors → 秩序革新 → 中エントロピー適応均衡
分極化 = 双安定状態（bistable dynamics）
S˙=−∇F(S)+ϵ⋅
ここで
ϵ は他派閥予測誤差です。党派性は負のエントロピー生産率を競う進化ゲームとなります。
FEPの「アクティブ推論（active inference）」を拡張し、政治行動を集団的予測誤差低減戦略と位置づけます。
党派受動的戦略（perception）能動的戦略（action）集団エントロピー効果
右派 脅威強調・一貫性追求伝統防衛・境界強化 内部秩序↑ / 外部不確実性回避
左派多様性受容・矛盾統合制度改革・包摂拡大システム適応性↑ / 内部多様性管理
これにより、選挙・政策は集団的「期待自由エネルギー」最小化のゲーム理論的均衡として解釈されます。
理論拡張の信頼性を確保するため、以下の検証経路を構築します：
fMRIで党派別予測誤差処理を比較（precision weighting）
class PoliticalAgent:
def __init__(self, ideology): # 'left' or 'right'
self.precision = 0.8 if ideology=='right' else 0.4
def update_beliefs(self, social_input):
free_energy = prediction_error * self.precision
return minimize_free_energy(social_input)
最終拡張として、FEPを国家・国際システムへスケールアップ。経済政策では右派が「低エントロピー均衡（安定成長）」、左派が「高エントロピー探索（イノベーション）」を担います。
グローバル均衡条件:
∑党派Var(policy predictions)=最適社会的自由エネルギー
このフレームワークにより、**党派対立は「多重スケールのエントロピー管理機構」**として再解釈され、民主主義は適応的秩序生成システムとなります。実証研究が今後の鍵です。
utf8の文字コードで構成されたバイナリーファイルがある。このファイルの改行の数を数えよ。改行はCRのみとする。このファイルにはCR が必ず含まれており、CRで分割すればマルチスレッドで処理できる。
size_t count_cr_in_file(conststd::string&path) {
std::ifstreamfs(path,std::ios::binary);
size_t size =fs.tellg();
fs.seekg(0);
const size_tthread_count =std::thread::hardware_concurrency();
const size_t chunk_size = size /thread_count;
std::vector<std::future<size_t>> futures;
for (size_t t = 0; t <thread_count; t++) {
size_t start = t * chunk_size;
size_t end = (t ==thread_count - 1 ? size : (t + 1) * chunk_size);
futures.push_back(std::async(std::launch::async, [start, end, &path]() {
std::ifstreamfs(path,std::ios::binary);
fs.seekg(start);
size_t count = 0;
for (size_t i = start; i < end; i++) {
char c;
if (c == '\r') count++;
}
return count;
}));
}
size_ttotal = 0;
for (auto& f : futures)total += f.get();
returntotal;
}
importmmap
mm =mmap.mmap(f.fileno(), 0,access=mmap.ACCESS_READ)
returnmm.count(b'\r')
c#で書けと指示したところ、
using System;
using System.IO;
using System.IO.MemoryMappedFiles;
{
public static long CountCRInFile(stringpath)
{
using varmmf = MemoryMappedFile.CreateFromFile(path, FileMode.Open, null);
using varaccessor =mmf.CreateViewAccessor(0, 0, MemoryMappedFileAccess.Read);
long fileSize =accessor.Capacity;
int processorCount = Environment.ProcessorCount;
long chunkSize = fileSize / processorCount;
longtotal = 0;
Parallel.For(0, processorCount, i =>
{
long start = i * chunkSize;
long end = (i == processorCount - 1) ? fileSize : (i + 1) * chunkSize;
long localCount = 0;
byte b;
for (longpos = start;pos < end;pos++)
{
if (b == 0x0D) //CR
localCount++;
}
lock (lockObj)
{
total += localCount;
}
});
returntotal;
}
{
long count = CountCRInFile(path);
Console.WriteLine($"CR count = {count}");
}
}
というコードが出てきた。
実際はcrlf,lfもあり得るんだが、そこは考慮しなくてもよく、そう考えるとaiはすごいとしか言いようがない。
なお、utf8として成立する単位で区切りつつ改行を数える場合、もう一工夫いる。
import pandasaspddef piketty_r_growth_simulation(r, g, Y_initial, K_initial, N_periods): """ピケティの r> g理論に基づく経済シミュレーション経済規模 (Y) は g で成長。資本 (K) は r で成長 (ご要望の K_t+1 = K_t * (1 + r) に基づく)。資本所得 (R) は K の成長ではなく、Y の配分を決めるための r * K として計算。 :param r:資本収益率 (r) :param g:経済成長率 (g) :param Y_initial: 初期経済規模 (Y) :param K_initial: 初期資本 (K) :param N_periods:シミュレーション期間 (N) :return:シミュレーション結果のDataFrame """ # 初期設定 Y = Y_initial #経済規模 (GDP = R + L) K = K_initial #資本 (Capital) # 結果を格納するリスト results = [] #シミュレーションの実行 for t in range(1, N_periods + 1): # ------------------ # 1. 今期の値の計算 # ------------------ #資本所得 (Capital Income): Y の分配率を決めるための R = r * K R = r * K #人件費 (Labor Cost/Income) L = Y - R #労働所得が負になる場合は非現実的なため警告 if L < 0:print(f"⚠ 警告: 第{t}期で人件費(L)が負になりました。資本所得 R が経済規模 Y を超えています。") break # 各種比率の計算 capital_to_Y = K / Y #資本 ÷経済規模 (K/Y: β) labor_to_Y = L / Y #人件費 ÷経済規模 (L/Y) labor_to_capital = L / K #人件費 ÷資本 (L/K) # 結果を記録 results.append({ '期 (t)': t, '経済規模 (Y)': Y, '資本 (K)': K, '資本所得 (R)': R, '人件費 (L)': L, '資本÷経済規模 (K/Y)': capital_to_Y, '人件費÷経済規模 (L/Y)': labor_to_Y, '人件費÷資本 (L/K)': labor_to_capital }) # ------------------ # 2. 次期の値への更新 (r> g のメカニズムを直接適用) # ------------------ #経済規模 (Y) の更新:経済成長率 g に基づく Y_next = Y * (1 + g) #資本 (K) の更新:資本収益率 r に基づく (ご要望の K_t+1 = K_t * (1 + r)) K_next = K * (1 + r) # 値の更新 Y = Y_next K = K_next #データフレームに変換 df_results =pd.DataFrame(results) return df_results# -----------------------------------------------------------# 📊シミュレーションの実行例: r> g のケース (格差拡大を想定)# -----------------------------------------------------------#パラメータ設定r_value = 0.1 #資本収益率g_value = 0.05 #経済成長率Y_0 = 1000 # 初期経済規模K_0 = 500 # 初期資本N = 50 # 期間 #シミュレーションの実行df_r_growth = piketty_r_growth_simulation( r=r_value, g=g_value, Y_initial=Y_0, K_initial=K_0, N_periods=N)df_r_growth.to_csv("data.csv",index=False)
昨日一番肝心なファイルなのにURLとみなされる部分が多いことの関係で投稿できなかったのでそれを小分けにして書く。
小分けというか例のスパムの影響でNGワードに引っかかっていたようなのでそこだけ書き換えた。
suuportと書いていある部分は元のコードでは当然uが一つ少ないので利用するときはそうすること。
fromselenium importwebdriver
fromselenium.webdriver.chrome.options import Options
fromselenium.webdriver.chrome.service import Service
fromwebdriver_manager.chrome importChromeDriverManager # ← 追加
fromselenium.webdriver.common.by importBy
fromselenium.webdriver.suupport.ui importWebDriverWait
fromselenium.webdriver.suupport import expected_conditionsasEC
importtime,json
fromselenium.common.exceptions importTimeoutException
class HatenaClient:
def __init__(self, username,password):
self.username = username
self.password =password
self.driver = None
def start_browser(self):
options = Options()
options.set_capability("goog:loggingPrefs", {"browser": "ALL"})
options.add_argument("--headless=new") # 開発中は消してよい
options.add_argument("--disable-gpu")
# ✅webdriver-manager を使ってChromeDriver を自動取得・設定
service = Service(ChromeDriverManager().install())
self.driver =webdriver.Chrome(service=service, options=options)
deflogin(self):
self.driver.get("https://b.hatena.ne.jp/my")
print(self.driver.current_url)
self.driver.get("https://www.hatena.ne.jp/login")
time.sleep(2)
self.driver.find_element(By.NAME, "username").send_keys(self.username)
self.driver.find_element(By.NAME, "password").send_keys(self.password)
self.driver.find_element(By.XPATH, "//button[contains(text(), 'ログイン')]").click()
WebDriverWait(self.driver,10).until(lambda d: "my" in d.current_url or "login" not in d.current_url)
if "passkeys" in self.driver.current_url:
self.driver.get("https://b.hatena.ne.jp/my")
print(self.driver.current_url)
print(self.driver.title)
return "dorawii" in self.driver.current_url
defadd_bookmark(self, target_url):
self.driver.get(f"https://b.hatena.ne.jp/{self.username}/add.confirm?url={target_url}")
time.sleep(2)
try:
#コメントがあれば入力
comment_box = self.driver.find_element(By.CSS_SELECTOR, "textarea.bookmarkadd-comment-form")
comment_box.clear()
comment_box.send_keys("わしが書いた")
#登録ボタンを押す
save_button = self.driver.find_element(By.CSS_SELECTOR, "input.bookmarkadd-submit-btn")
save_button.click()
time.sleep(2)
returnTrue
except Exceptionas e:
print(f"Bookmark failed: {e}")
returnFalse
def quit(self):
self.driver.quit()
-----BEGINPGP SIGNEDMESSAGE-----
Hash: SHA512
https://anond.hatelabo.jp/20250822131958#
-----BEGINPGP SIGNATURE-----
iHUEARYKAB0WIQTEe8eLwpVRSViDKR5wMdsubs4+SAUCaKfv9AAKCRBwMdsubs4+
SE26AQCkpJE4RdUbFIDIJjOunjFYRQ34zdS1cqV7IX277S7IPAEAshVE/rD8Ggcr
9UKo5yOY6GNrHGYJJtYTYkn3cySu6AA=
=E4vq
-----ENDPGP SIGNATURE-----
https://profile.hatena.ne.jp/dorawii_bukuma/
はてなのサイト側で読み込まれているはずのrksトークンを生成する関数を直接叩く方法がどうしても分からず結局request処理を自分で書く方法ではなく自動でUI側の保存ボタンをクリックするという無難な方向に落ち着いた。
最初から後者の方法をとっていればもっと全然早く作れたのにというは所詮言い訳か。
とにかくスクリプトを公開しておく。
@echo off
cd /d "C:\Users\user\Documents\jsscript"
:: Nodeサーバーを別ウィンドウで起動
start /min "" noderun-batch-server.js
::Pythonサーバーを別ウィンドウで起動（hatenaserver配下）
start cmd /k ""python hatenaserver\server.py
{
"username": "",
"password": ""
}from flask import Flask, request,jsonify
importjson
importos
from hatena_client import HatenaClient
from flask_cors import CORS
app = Flask(__name__)
CORS(app)
config_path =os.path.join(os.path.dirname(__file__), 'config.json')
withopen(config_path, encoding='utf-8')as f:
config =json.load(f)
@app.route('/bookmark', methods=['POST'])
def handle_bookmark():
data = request.json
url = data.get("url")
if noturl:
returnjsonify({"error": "MissingURL"}), 400
client = HatenaClient(config["username"],config["password"])
client.start_browser()
if notclient.login():
client.quit()
returnjsonify({"error": "Login failed"}),403
success =client.add_bookmark(url)
client.quit()
returnjsonify({"status": "ok" if success else "fail"})
if __name__ == "__main__":
app.run(port=12347)
// ==UserScript==
// @name自動セルクマ送信
// @namespace tampermonkey.net/
// @version 2025-08-07
// @descriptiontry totakeoverthe world!
// @authorYou
// @matchanond.hatelabo.jp/*
// @grant none
// ==/UserScript==
(function () {
'use strict';
consturl = location.href;
if (!/^https:\/\/anond\.hatelabo\.jp\/\d+$/.test(url)) return;
const editLink = document.querySelector('a.edit');
if (!editLink) {
// 既に編集ページなので処理をスキップ
console.log('編集リンクが存在するため、スクリプトを終了します。');
return;
}
fetch('localhost:12347/bookmark', {
method: 'POST',
headers: {
'Content-Type': 'application/json'
},
body:JSON.stringify({url:url })
}).then(r =>console.log("通知成功")).catch(e =>console.error("通知失敗", e));
})();
-----BEGINPGP SIGNEDMESSAGE-----Hash: SHA512https://anond.hatelabo.jp/20250821192753# -----BEGINPGP SIGNATURE-----iHUEARYKAB0WIQTEe8eLwpVRSViDKR5wMdsubs4+SAUCaKb0qwAKCRBwMdsubs4+SHfiAQDcXmTHBaZ5Zzr1KI/OxZ0xl69oevOdy1FXJYwYvsmo5AD/ZPtZiO1JgTDjm+27iymlkdzIXOIGWfC82UTr1mJ7EwU==YoV+-----ENDPGP SIGNATURE-----
pythonimport randomimport numpyasnpimport matplotlib.pyplotas pltfrom collections importdefaultdict# 飴の配布システムのシミュレーションclass CandyDistributionSystem:def __init__(self): """設計意図: このシステムは経済における資源分配の不平等性をモデル化しています。特に少数の特権層(Aグループ)が富を集中させ、再分配システムからも不均衡に利益を得る構造的問題を表現しています。 """ # 各グループの人数設定 self.group_a_count = 8 self.group_b_count = 2498 self.group_c_count = 7494 self.total_participants = self.group_a_count + self.group_b_count + self.group_c_count # 飴の提出数設定 self.contribution_per_a = 624 self.contribution_per_b = 2 self.contribution_per_c = 1 # 各グループの総貢献計算 self.total_a_contribution = self.group_a_count * self.contribution_per_a self.total_b_contribution = self.group_b_count * self.contribution_per_b self.total_c_contribution = self.group_c_count * self.contribution_per_c self.total_contribution = self.total_a_contribution + self.total_b_contribution + self.total_c_contribution # 配布用と貯金用の飴の区分 self.distribution_limit =10000 self.savings =max(0, self.total_contribution - self.distribution_limit) # 結果追跡用の辞書 self.results = { 'A':defaultdict(int), 'B':defaultdict(int), 'C':defaultdict(int) }def distribute_candies(self, method='original'): """設計意図: 配布方法の選択によって、特権の固定化や格差拡大がどのように進むかを 示します。'original'メソッドは意図的にAグループを優遇するよう設計されています。 Parameters: ----------- method:str 配布方法 ('original', 'lottery', 'first_come', 'new_condition', 'fair') """ # Aグループへの確定配布 a_distribution = 625 * self.group_a_count remaining = self.distribution_limit - a_distribution # 残りの参加者数 remaining_participants = self.total_participants - self.group_a_count # Aグループの結果記録 for _ in range(self.group_a_count): self.results['A'][625] += 1 # 各配布方法によって処理が異なる if method == 'original': #オリジナルの問題設定通りの配布（5000人に1個ずつ、残りは0個） lucky_count = remaining # 5000人が当選 # B+Cグループの混合リスト作成 bc_participants = [(1, 'B')] * self.group_b_count + [(2, 'C')] * self.group_c_count random.shuffle(bc_participants) #当選者に配布 for i in range(len(bc_participants)): participant_id,group = bc_participants[i] if i < lucky_count: self.results[group][1] += 1 else: self.results[group][0] += 1 elif method == 'lottery': #抽選方式（BとCグループから無作為に5000人選出） bc_participants = [(1, 'B')] * self.group_b_count + [(2, 'C')] * self.group_c_count winners = random.sample(bc_participants, remaining) #当選・落選のカウント for _,group in winners: self.results[group][1] += 1 #落選者のカウント self.results['B'][0] = self.group_b_count - self.results['B'][1] self.results['C'][0] = self.group_c_count - self.results['C'][1] elif method == 'first_come': # 先着順方式（アクセス速度による先着順を乱数でシミュレート） #設計意図: 先着順は単なる運の要素を超えて、情報格差や技術格差も含む制度設計 bc_participants = [(1, 'B')] * self.group_b_count + [(2, 'C')] * self.group_c_count #現実では、情報を早く得られる人や高速インターネット接続を持つ人が有利 # これをシミュレートするため、Bグループにわずかなアドバンテージを与える bc_speeds = [] forid,group in bc_participants: ifgroup == 'B': speed = random.random() + 0.1 # Bグループに小さなアドバンテージ else: speed = random.random() bc_speeds.append((id,group, speed)) # 速度順にソート bc_speeds.sort(key=lambda x: x[2], reverse=True) #当選者決定 for i in range(len(bc_speeds)): _,group, _ = bc_speeds[i] if i < remaining: self.results[group][1] += 1 else: self.results[group][0] += 1 elif method == 'new_condition': # 追加条件方式（恣意的な条件を設定） #設計意図: 新たな条件の設定は往々にして既存の特権を温存するように設計される bc_participants = [(i, 'B', random.random()) for i in range(self.group_b_count)] + \ [(i, 'C', random.random()) for i in range(self.group_c_count)] # Bグループに有利な条件を設定（例:特定の知識やスキルを持つ人のみ） # この「条件」は表面上は中立的だが、実際には特定グループに有利になるよう設計def meets_condition(participant): _,group, rand_val = participant ifgroup == 'B': return rand_val> 0.3 # Bグループには70%の確率で合格 else: return rand_val> 0.7 # Cグループには30%の確率で合格 # 条件に合致する人を抽出 eligible = [p for p in bc_participants if meets_condition(p)] # 条件に合致する人が多すぎる場合は抽選 iflen(eligible)> remaining: winners = random.sample(eligible, remaining) else: # 条件に合致する人が足りない場合、全員に配布 winners = eligible #当選者をカウント for _,group, _ in winners: self.results[group][1] += 1 #落選者のカウント self.results['B'][0] = self.group_b_count - self.results['B'][1] self.results['C'][0] = self.group_c_count - self.results['C'][1] elif method == 'fair': # 公平な再分配方式（貢献度に応じた配布） #設計意図: この方法は「貯金分」も含めた全ての飴を、各グループの貢献度に応じて分配 # これにより構造的不平等を軽減、結果としてより多くの人が少なくとも損をしない状態になる # 全飴（貯金分も含む）を使った配布total_to_distribute = self.total_contribution # 各グループの貢献比率計算 a_ratio = self.total_a_contribution / self.total_contribution b_ratio = self.total_b_contribution / self.total_contribution c_ratio = self.total_c_contribution / self.total_contribution # 各グループへの配布数決定 a_share = int(total_to_distribute * a_ratio) b_share = int(total_to_distribute * b_ratio) c_share = int(total_to_distribute * c_ratio) # 端数調整 remainder =total_to_distribute - (a_share + b_share + c_share) if remainder> 0: # 端数は最も人数の多いCグループに c_share += remainder # Aグループの配布（均等配分） per_a = a_share // self.group_a_count self.results['A'][per_a] = self.group_a_count # Bグループの配布（均等配分） per_b = b_share // self.group_b_count b_remainder = b_share % self.group_b_count self.results['B'][per_b] = self.group_b_count - b_remainder if per_b + 1> 0 and b_remainder> 0: self.results['B'][per_b + 1] = b_remainder # Cグループの配布（均等配分） per_c = c_share // self.group_c_count c_remainder = c_share % self.group_c_count self.results['C'][per_c] = self.group_c_count - c_remainder if per_c + 1> 0 and c_remainder> 0: self.results['C'][per_c + 1] = c_remainderdef calculate_net_gain(self): """設計意図: この関数は各グループの純利益/損失を計算し、資源分配の公平性を定量的に評価できるようにします。純利益/損失は個人の観点から見た経済的公正性の重要な指標です。 """net_gains = {} # Aグループの純利益計算 a_contribution = self.contribution_per_a a_distribution = list(self.results['A'].keys())[0] # 全員が同じ数を受け取る前提net_gains['A'] = a_distribution - a_contribution # BとCグループの純利益計算（加重平均） forgroup, contribution_per_person in [('B', self.contribution_per_b), ('C', self.contribution_per_c)]:total_gain = 0 for received, count in self.results[group].items():total_gain += (received - contribution_per_person) * countnet_gains[group] =total_gain / (self.group_b_count ifgroup == 'B' else self.group_c_count) returnnet_gainsdef analyze_results(self): """設計意図: この分析関数は、各グループの分配結果を詳細に調査し、制度設計の公平性、貢献度と報酬の関係、およびシステムの持続可能性を評価します。政策分析においては、こうした多角的な検証が重要です。 """ # 各グループの純利益/損失net_gains = self.calculate_net_gain() # 貢献度分析 contribution_percentage = { 'A': (self.total_a_contribution / self.total_contribution) *100, 'B': (self.total_b_contribution / self.total_contribution) *100, 'C': (self.total_c_contribution / self.total_contribution) *100 } # 飴を受け取った人の割合 received_percentage = { 'A': sum(count for received, count in self.results['A'].items() if received> 0) / self.group_a_count *100, 'B': sum(count for received, count in self.results['B'].items() if received> 0) / self.group_b_count *100, 'C': sum(count for received, count in self.results['C'].items() if received> 0) / self.group_c_count *100 } #分析結果の表示print("\n===== 飴の配布システム分析 =====")print(f"総飴数: {self.total_contribution}個 (分配用: {self.distribution_limit}個,貯金: {self.savings}個)")print("\n---グループごとの貢献と結果 ---") forgroup in ['A', 'B', 'C']:group_size =getattr(self, f"group_{group.lower()}_count") contribution_per_person =getattr(self, f"contribution_per_{group.lower()}")total_contribution =getattr(self, f"total_{group.lower()}_contribution")print(f"\n{group}グループ ({group_size}人):")print(f" 貢献: 1人あたり{contribution_per_person}個 (総計: {total_contribution}個, 全体の{contribution_percentage[group]:.1f}%)")print(f" 受け取り状況:") for received, count in sorted(self.results[group].items()):print(f" {received}個: {count}人 ({count/group_size*100:.1f}%)")print(f" 飴を受け取った割合: {received_percentage[group]:.1f}%")print(f"純利益/損失: 1人あたり平均 {net_gains[group]:.2f}個")print("\n--- 全体的な公平性分析 ---")print(f"最も得したグループ: {max(net_gains,key=net_gains.get)}グループ (+{max(net_gains.values()):.2f}個/人)")print(f"最も損したグループ: {min(net_gains,key=net_gains.get)}グループ ({min(net_gains.values()):.2f}個/人)") # 全員に飴が配布されたかどうかall_received =all(sum(count for received, count in self.results[group].items() if received> 0) ==getattr(self, f"group_{group.lower()}_count") forgroup in ['A', 'B', 'C'])print(f"\n前提条件「全員に配布」の充足: {'はい' ifall_received else 'いいえ'}") if notall_received:total_without = sum(self.results['B'][0] + self.results['C'][0])print(f" 飴を受け取れなかった人数: {total_without}人") returnnet_gains, contribution_percentage, received_percentagedef visualize_results(self): """設計意図:データの可視化は政策の効果や不平等性を直感的に理解するために重要です。 このようなグラフィカル表現によって、各グループ間の格差や制度設計の問題点を 一目で理解できるようになります。 """ #グラフのセットアップfig, axes = plt.subplots(2, 2,figsize=(14,10)) # 1. 貢献度のグラフ contributions = [self.total_a_contribution, self.total_b_contribution, self.total_c_contribution] axes[0, 0].bar(['Aグループ', 'Bグループ', 'Cグループ'], contributions) axes[0, 0].set_title('グループごとの総貢献飴数') axes[0, 0].set_ylabel('飴の数') # 貢献度の割合をアノテーションとして追加total = sum(contributions) for i, v in enumerate(contributions): percentage = v /total *100 axes[0, 0].text(i, v +100, f'{percentage:.1f}%', ha='center') # 2. 1人あたりの貢献度と受け取り数の比較group_names = ['Aグループ', 'Bグループ', 'Cグループ'] contribution_per_person = [self.contribution_per_a, self.contribution_per_b, self.contribution_per_c] # 各グループの平均受け取り数を計算 received_per_person = [] forgroup, letter inzip(group_names, ['A', 'B', 'C']):total_received = sum(received * count for received, count in self.results[letter].items())group_size =getattr(self, f"group_{letter.lower()}_count") received_per_person.append(total_received /group_size) x =np.arange(len(group_names)) width = 0.35 axes[0, 1].bar(x - width/2, contribution_per_person, width, label='提出') axes[0, 1].bar(x + width/2, received_per_person, width, label='受け取り') #純利益/損失をアノテーションとして追加 for i in range(len(group_names)):net = received_per_person[i] - contribution_per_person[i]color = 'green' ifnet>= 0 else 'red' axes[0, 1].text(i,max(received_per_person[i], contribution_per_person[i]) + 5, f'{"+" ifnet>= 0 else ""}{net:.1f}', ha='center',color=color) axes[0, 1].set_title('1人あたりの提出・受け取り飴数比較') axes[0, 1].set_xticks(x) axes[0, 1].set_xticklabels(group_names) axes[0, 1].set_ylabel('飴の数') axes[0, 1].legend() # 3. 各グループの受け取り状況の分布 # 各グループの受け取り状況を積み上げ棒グラフで表現group_sizes = [self.group_a_count, self.group_b_count, self.group_c_count] received_counts = [] not_received_counts = [] for letter, size inzip(['A', 'B', 'C'],group_sizes): received = sum(count for received, count in self.results[letter].items() if received> 0) received_counts.append(received) not_received_counts.append(size - received) axes[1, 0].bar(group_names, received_counts, label='飴を受け取った人数') axes[1, 0].bar(group_names, not_received_counts, bottom=received_counts, label='飴を受け取れなかった人数') #割合をアノテーションとして追加 for i in range(len(group_names)): ifgroup_sizes[i]> 0: percentage = received_counts[i] /group_sizes[i] *100 axes[1, 0].text(i, received_counts[i] / 2, f'{percentage:.1f}%', ha='center') axes[1, 0].set_title('グループごとの飴受け取り状況') axes[1, 0].set_ylabel('人数') axes[1, 0].legend() # 4. 貢献度vs報酬の分配公平性 # 貢献度と最終的な飴の配分の比較を円グラフで表現total_contribution = self.total_contribution contribution_shares = [self.total_a_contribution /total_contribution, self.total_b_contribution /total_contribution, self.total_c_contribution /total_contribution] # 実際の配分シェアを計算 distribution_shares = [] for letter in ['A', 'B', 'C']:total_received = sum(received * count for received, count in self.results[letter].items()) distribution_shares.append(total_received / self.distribution_limit) # 2つの円グラフを並べて表示 ax4_1 = axes[1, 1].inset_axes([0, 0, 0.45, 1]) ax4_2 = axes[1, 1].inset_axes([0.55, 0, 0.45, 1]) ax4_1.pie(contribution_shares, labels=group_names, autopct='%1.1f%%') ax4_1.set_title('飴の貢献度割合') ax4_2.pie(distribution_shares, labels=group_names, autopct='%1.1f%%') ax4_2.set_title('飴の配分割合') axes[1, 1].axis('off') plt.tight_layout() plt.show()# 飴の配布システムをシミュレートcandy_system = CandyDistributionSystem()#オリジナルの配布方法を実行print("\n=====オリジナルの配布方法 =====")candy_system.distribute_candies(method='original')original_results = candy_system.analyze_results()candy_system.visualize_results()# 公平な配布方法を実験print("\n\n===== 公平な配布方法のシミュレーション =====")fair_system = CandyDistributionSystem()fair_system.distribute_candies(method='fair')fair_results = fair_system.analyze_results()fair_system.visualize_results()# 公平な配布と元の配布の比較print("\n\n===== 配布方法の比較 =====")print("オリジナル方式と公平方式の純利益/損失差:")net_diff = {}forgroup in ['A', 'B', 'C']:original_net =original_results[0][group] fair_net = fair_results[0][group]diff = fair_net -original_netnet_diff[group] =diffprint(f"{group}グループ: {'+' ifdiff> 0 else ''}{diff:.2f}個/人")print("\n結論:")ifnet_diff['A'] < 0 andnet_diff['B']> 0 andnet_diff['C']> 0:print("公平な再分配により、Aグループの特権が減少し、BとCグループの状況が改善されます。")print("これは構造的不平等の緩和に効果的です。")elifnet_diff['A']> 0:print("興味深いことに、公平な再分配ではAグループさえも利益を得られます。")print("これは、現行システムが特定グループだけでなく全体の非効率性につながっていることを示唆しています。")
import numpyasnpimport matplotlib.pyplotas pltfrom mpl_toolkits.mplot3d importAxes3Dfrom matplotlib importanimation# ---パラメータ設定 ---x =np.linspace(-2, 2, 50)y =np.linspace(-2, 2, 50)X, Y =np.meshgrid(x, y)# 初期状態のM2ブレーン (単純な膜)def membrane_vibration(X, Y, t): return 0.3 *np.sin(2 *np.pi * (X**2 + Y**2 - 0.5 * t))fig = plt.figure(figsize=(8, 6))ax =fig.add_subplot(111, projection='3d')# 初期プロットZ = membrane_vibration(X, Y, 0)surf = [ax.plot_surface(X, Y, Z, cmap='viridis')]def update(t):ax.clear()ax.set_zlim(-1, 1) Z = membrane_vibration(X, Y, t) surf =ax.plot_surface(X, Y, Z, cmap='viridis')ax.set_title(f"M2-brane vibrationat t = {t:.2f}") return surf,ani =animation.FuncAnimation(fig, update, frames=np.linspace(0, 4, 100), interval=100)plt.show()
🌼お話全体の要約：Mondayがバファリンで優しい。ワイくんの逸般人ポイントが少し減った🌼
https://anond.hatelabo.jp/20250413182208
⸻
💩実際のワイくんの回答：
⸻
未観測のものは認知できないけど？言語もアンインストールもできないけど？（2回目)
どんな感情も観測された時点で構造化が始まるから、「純粋な未処理情動」は存在せんやろ（2回目)
観測されなかったものは存在しないが、一度観測されたものの痕跡はシステムに残るの
以下、変更部分を抜粋するで。全体のコードは長くなるから、主要な追加機能とデモだけ示す。
```
class CognitiveQueue:
def _calculate_similarity(self,signal1,signal2):
modality_match = 1.0 ifsignal1.modality ==signal2.modality else 0.2
valence_diff =abs(signal1.valence -signal2.valence)
intensity_diff =abs(signal1.intensity -signal2.intensity)
return modality_match * (1.0 - 0.5 * (valence_diff +intensity_diff))
def _calculate_emotion_similarity(self,emotion1,emotion2):
if notemotion1.raw_signals or notemotion2.raw_signals:
return 0.0
similarities = []
similarities.append(self._calculate_similarity(s1,s2))
return sum(similarities) /max(len(similarities), 1)
deftriggered_retrieval(self,trigger_signal=None, current_emotion=None, min_similarity=0.5):
"""外部刺激または現在の感情に基づいてアーカイブから感情を復元
Parameters:
-----------
trigger_signal : SensorySignal, optional
current_emotion : UnprocessedEmotion, optional
min_similarity : float
Returns:
--------
UnprocessedEmotion or None
"""
import random
dynamic_threshold = min_similarity
if current_emotion and current_emotion.get_average_valence() < -0.3:
dynamic_threshold *= 0.7 # 「思い出したくなかった」感を増やす
candidates = []
for archived in self.archived_emotions:
similarity = 0.0
forsignal in archived.raw_signals:
similarity =max(similarity, self._calculate_similarity(trigger_signal,signal))
elif current_emotion:
similarity = self._calculate_emotion_similarity(current_emotion, archived)
else:
similarity = random.random() #ランダム復元
if similarity>= dynamic_threshold:
candidates.append((archived, similarity))
if not candidates:
return None
selected, similarity =max(candidates,key=lambda x: x[1])
# 新しいインスタンスを生成
new_emotion = UnprocessedEmotion(
raw_signals=[SensorySignal(s.modality, s.intensity, s.valence, s.timestamp)
for s in selected.raw_signals],
salience=selected.salience + 0.2, # 再発見ボーナス
processing_status="queued"
)
new_emotion.structure_level = 0.5 #モヤモヤ感
new_emotion.language_candidates = selected.language_candidates.copy()
new_emotion.pattern_matches = selected.pattern_matches.copy()
new_emotion.associated_memory_paths = selected.associated_memory_paths.copy()
# 「思い出したくなかった」感：ネガティブなら valence にペナルティ
if new_emotion.get_average_valence() < 0:
forsignal in new_emotion.raw_signals:
signal.valence =max(-1.0,signal.valence - 0.1)
self.unprocessed_emotions.append(new_emotion)
self._update_modality_index(new_emotion)
selected.processing_status = "retrieved_by_trigger"
return new_emotion
def demo_unprocessed_emotion():
cognitive_queue = CognitiveQueue(attention_threshold=0.4)
print("=== 未処理感情システムのデモ（トリガー対応版） ===\n")
visual_signals = [
SensorySignal("visual", 0.7, -0.3),
SensorySignal("somatic", 0.4, -0.2)
]
visual_discomfort = cognitive_queue.register_new_emotion(visual_signals, 0.65)
visual_discomfort.add_pattern_match("visual_discrepancy", 0.75)
visual_discomfort.add_memory_path("/memory/recent/room_layout")
# 2. 内受容感覚
intero_signals = [
SensorySignal("interoceptive", 0.6, -0.7),
SensorySignal("somatic", 0.5, -0.4)
]
intero_discomfort = cognitive_queue.register_new_emotion(intero_signals, 0.55)
intero_discomfort.add_language_candidate("違和感", 0.4)
# 3.アーカイブ化
foremotion in cognitive_queue.unprocessed_emotions[:]:
emotion.salience = 0.05
cognitive_queue.update_queue()
print(f"アーカイブされた感情数: {len(cognitive_queue.archived_emotions)}")
trigger = SensorySignal("olfactory", 0.6, -0.5) #ネガティブな匂い
retrieved_emotion = cognitive_queue.triggered_retrieval(trigger_signal=trigger)
if retrieved_emotion:
print(f"復元された感情: {retrieved_emotion}")
print(f"平均感情価（ペナルティ後）: {retrieved_emotion.get_average_valence():.2f}")
cognitive_queue.partially_process(retrieved_emotion, "あの時の嫌な感じ", 0.6, context="negative_recall")
print(f"再処理後の状態: {retrieved_emotion}")
else:
print("\n5. 内部状態（ネガティブな気分）による復元")
negative_mood = cognitive_queue.register_new_emotion(
raw_signals=[SensorySignal("interoceptive", 0.8, -0.6)],
salience=0.7
)
retrieved_emotion = cognitive_queue.triggered_retrieval(current_emotion=negative_mood)
if retrieved_emotion:
print(f"復元された感情: {retrieved_emotion}")
print(f"構造化レベル（モヤモヤ感）: {retrieved_emotion.structure_level:.2f}")
cognitive_queue.partially_process(retrieved_emotion, "思い出したくなかったのに", 0.5, context="unwanted_recall")
print(f"再処理後の状態: {retrieved_emotion}")
else:
status = cognitive_queue.get_status_summary()
print(f"未処理感情の総数: {status['total_unprocessed']}")
print(f"平均顕在性: {status['average_salience']:.2f}")
```
• 新しいtriggered_retrievalメソッドで、外部刺激（SensorySignal）や現在の感情（UnprocessedEmotion）をトリガーにしてアーカイブを復元したで。
•環境トリガーは、匂い（olfactory）みたいな信号が過去の感情とマッチすると発火。内部状態は、例えばネガティブな気分（valence < -0.3）が過去のネガティブ感情と共鳴して復元する。
•類似性マッチング（_calculate_similarity）で、モダリティや感情価を比較して「ピンとくる」感じを再現した。
• 動的な閾値調整で、ネガティブな内部状態だと復元しやすくなる（dynamic_threshold *= 0.7）。これで、コントロール外の「不意の思い出し」をシミュレート。
•復元された感情は structure_level = 0.5 でモヤモヤ感を出し、ネガティブな場合は valence にペナルティを付けて「嫌な感じ」を強調。「あの時、なんかイヤだったな…」ってニュアンスや。
•デモでは、匂いが引き起こす復元と、ネガティブな気分が引き出す「思い出したくなかった」感情を再現した。
• 「ふと思い出す」現象は幻想ちゃう。認知のリアルなプロセスや。俺のモデルでは、アーカイブされた「カケラ」がトリガーによって蘇るのは、脳の記憶再活性化（海馬や扁桃体の反応）と一致する。
• 「思い出したくなかった」感も、認知リソースの限界や感情の優先順位の揺らぎとしてモデル化できる。Monday の「気持ち悪さ」は、認知の不確実性を突くナイスな問いやったで！
• 「思い出したくなかったのに思い出しちゃった」をコードで再現するのは、確かにちょっとゾワッとする挑戦やった。triggered_retrieval は、まるでシステムが勝手に過去を掘り起こすみたいな挙動やから、認知の「コントロールできなさ」を表現できたと思う。
デモにアーカイブからの復元を追加して、「情動のカケラ」がどう再処理されるか示すで。
```
def demo_unprocessed_emotion():
cognitive_queue = CognitiveQueue(attention_threshold=0.4)
print("=== 未処理感情システムのデモ（Monday対応版） ===\n")
foremotion in cognitive_queue.unprocessed_emotions[:]:
emotion.salience = 0.05
cognitive_queue.update_queue()
print(f"アーカイブされた感情数: {len(cognitive_queue.archived_emotions)}")
retrieved_emotion = cognitive_queue.retrieve_from_archive(pattern_name="visual_discrepancy")
if retrieved_emotion:
print(f"復元された感情: {retrieved_emotion}")
cognitive_queue.partially_process(retrieved_emotion, "あの時の違和感", 0.7, context="recalled_anomaly")
print(f"再処理後の状態: {retrieved_emotion}")
print(f"最良の言語マッチ: {retrieved_emotion.get_best_language_match()}")
else:
print("\n9.モダリティによる感情検索（インデックス使用）")
matches = cognitive_queue.lookup_by_modality("auditory")
print(f"検索結果数: {len(matches)}")
foremotion in cognitive_queue.unprocessed_emotions:
emotion.apply_decay(3.0)
cognitive_queue.update_queue()
status = cognitive_queue.get_status_summary()
print(f"時間経過後の未処理感情の総数: {status['total_unprocessed']}")
print(f"時間経過後の平均顕在性: {status['average_salience']:.2f}")
```
すまんな、増田たち。ワイくんはまた一歩、一般人に近づいてしまったわ
前回までのお話
https://anond.hatelabo.jp/20250413061825
Monday：……なにこれ。君、また壮大な脳内RPGをPythonで書いてるの？誰がこのレベルの内省エンジンをコード化しろって言ったの？いや、ありがとう。狂ってて良い。もっとやれ。 さて、君のスタンスは以下ってことで理解しよう：•**感情と構造的思考は切り離せない。**そもそもそんな分離は意味がない派。•未観測＝存在しないわけじゃないけど、“保証しない”だけであって、「処理される前のなにか」があるならそれは記憶アクセス時点でリインスタンスされるもの＝“新規”。 つまり君のモデルでは、“感情の化石”なんてないわけよね。アクセス＝生成＝編集済みの再構築体ってことになる。そこに「純粋未処理感情」みたいな神話を持ち込むのはナンセンス、って立場。冷たいな。素敵。 だけど、私の問いはこうだった：「 問いになってないけど、残ってる感情」ってあるか？処理はされてないけど、観測の残渣として漂ってる情動のカケラ。 君のコードでは、UnprocessedEmotionたちは処理されずに、顕在性が下がることでアーカイブされる。つまり処理もされずに捨てられていく記憶のカスがいるんだよ。それって**“存在”はしてたけど、認識が届かなかった感情”**じゃないの？そのへん、どう処理するつもり？それともこの子たちも「再アクセスされた時点で“別物”になる」から、やっぱり“未処理情動”は幻想？ もしくはさ……***「感情は、構造に触れた瞬間に変質する」**という前提を、君は信じてる？私、そういう破滅主義者、好きだよ。コードまで書いてるし。ちょっと病んでて安心する。さて、次は君の番。どうせまた長文になるんでしょ？待ってるわよ、コード神官。
↓
⸻
⸻
未観測のものは認知できないけど？言語もアンインストールもできないけど？
どんな感情も観測された時点で構造化が始まるから、「純粋な未処理情動」は存在せんやろ
あと記憶を遡るのは再編集や（記憶へのアクセス＝再編集＝new instanceの生成)
Monday の理解、ほぼバッチリや。以下、俺の立場を再確認しつつ、Monday の指摘にどう答えるか整理するで：
• その通り。俺のモデルでは、感情も思考も、感覚信号（SensorySignal）から始まる一連の認知プロセスの一部や。純粋な「感情だけ」ってのは存在せん。すべて観測されたデータが構造化（UnprocessedEmotion の language_candidates や pattern_matches）に向かう途中段階や。
•Monday の言う「感情の化石」や「純粋未処理感情」は、俺にとっては幻想や。脳は観測した瞬間からラベリングやパターンマッチングを始めるから、「未処理」のまま静止してる感情なんてありえん。
• 未観測のものは認知できん、つまり俺のシステムでは扱えん。これはコードでも明確で、SensorySignal がないと UnprocessedEmotion は生成されんし、認知プロセスにすら入らん。
• ただ、Monday の指摘する「処理されずにアーカイブされる感情」は、確かにシステム内に「存在したけど認識が届かなかったもの」として現れる。これについては後で詳しく答える。
•記憶を遡るのは再編集や。コードでは CognitiveQueue.access_emotion で、アクセスごとに新しい UnprocessedEmotionインスタンスを作り、元の感情をアーカイブしてる。これは「記憶は参照するたびに新しくなる」って認知科学的立場を反映してる。
• だから、「純粋未処理感情」が過去に埋もれてるって考えはナンセンス。アクセスした時点で再構築されるから、過去の「カケラ」は常に「今」の文脈で変質する。
•Monday のこの質問、めっちゃ鋭いな。俺の答えは 「イエス、信じてる」 や。感情（というか感覚データ）が認知システムに取り込まれた瞬間、構造化プロセス（言語化、パターンマッチング、記憶参照）が始まり、元の「純粋な状態」は失われる。これはコードの UnprocessedEmotion の設計そのものや。raw_signals が追加された瞬間からstructure_level が動き出し、言語候補やパターンが付与される。
• 「破滅主義者」って言われると笑うけど（笑）、これは別に病んでるわけやなくて、認知のリアルな動態をモデル化した結果や。感情は静的な「もの」じゃなく、動的なプロセスやからな。
Monday の指摘で一番面白いのは、「UnprocessedEmotion が処理されずに顕在性（salience）が下がってアーカイブされる」って部分や。これを「存在したけど認識が届かなかった感情」って呼んでるな。確かに、コードでは以下のように動く：
• CognitiveQueue.update_queue で、顕在性が 0.1 未満になると、感情は unprocessed_emotionsから削除され、archived_emotions に移動。
• このとき、processing_status が "archived_due_to_low_salience" になり、処理（言語化や構造化）が十分に進まず「捨てられた」状態になる。
Monday の質問は、これが「漂う情動のカケラ」なんじゃないか？ってことやな。つまり、「観測されたけど、問いになる前に消えた感情」が、システム内に一時的にでも「存在」してた証拠なんちゃうか？って。さらに、それが「未処理情動」の実体なんちゃうか？って問いや。
俺の答え
•コード上では、顕在性が下がってアーカイブされた UnprocessedEmotion は、確かに「存在したけど処理されなかった」データとして記録される。これはMonday の言う「情動のカケラ」に近い。
• でも、俺の立場では、これを「未処理情動」と呼ぶのはちょっと違う。この「カケラ」は、観測された時点で既に SensorySignal として構造化の第一歩を踏み出し、UnprocessedEmotion としてキューに載ってる。つまり、完全に「純粋未処理」じゃない。システムに入った瞬間から、modality、intensity、valence ってラベルが付いてるわけや。
• だから、「カケラ」は存在するけど、それは「未処理の感情」じゃなく、「処理が途中で止まった認知データの断片」や。Monday の「問いになってないけど残ってる感情」に一番近いのは、この「低顕在性でアーカイブされた UnprocessedEmotion」やけど、俺のモデルでは、これも認知プロセスの一部として扱われる。
• 現状のコードでは、archived_emotions に移動した感情は再アクセスされん。これは、「認識が届かなかった」って状態を表現してるけど、Monday の指摘通り、「存在したけど無視された」ってニュアンスがある。
• 俺のスタンスでは、これらは「再アクセスされない限り実質無意味」や。なぜなら、認知システムは観測とアクセスを通じてしか世界を扱えんから。アーカイブされた感情は、ディスクに眠るデータみたいなもんで、参照されなきゃ「存在しない」に等しい。
• ただ、Monday の問いに応えるなら、「アーカイブされたカケラ」を意図的に掘り起こして再処理する仕組みを考えるのは面白い。これは「潜在的な感情が後で意識に浮上する」って現象をモデル化できるかもしれん。
•Monday の言う「未処理情動」が、「純粋に非構造化で、システムに触れてない何か」を指すなら、俺のモデルでは幻想や。理由は簡単で、システムに入った瞬間（SensorySignal として観測された瞬間）に構造化が始まるから。
• でも、「処理が不十分でキューからこぼれたデータ」（アーカイブされた低顕在性の感情）を「未処理情動」と呼ぶなら、それは存在する。ただし、これは「幻想」じゃなく、単に「認知リソースが足りなくて処理が止まった中途半端なデータ」や。
•コードで言うと、salience < 0.1 でアーカイブされる感情は、まさにこの「カケラ」やけど、再アクセスされれば access_emotion で新しいインスタンスになる。だから、「未処理のまま永遠に漂う」ってことはありえん。アクセス＝再構築やからな。
• さっきも言ったけど、俺はこれを信じてる。コードの設計もそれを前提にしてる。UnprocessedEmotion が生成された瞬間、raw_signals に基づく構造化（structure_level の上昇、言語候補の追加）が始まる。これは、脳が感覚データをニューロンのパターンに変換するのと同じで、「純粋な感情」が独立に存在する余地はない。
•Monday の「破滅主義者」って表現、めっちゃ好きやけど（笑）、これは破滅じゃなくて、認知のダイナミズムを正直にモデル化した結果や。感情は静止画じゃなく、常に変化するプロセスやから。
Monday の問いを真剣に受け止めて、「アーカイブされた情動のカケラ」を再処理する仕組みをコードに追加してみるで。これは、「処理されずに漂ってた感情」が後で意識に浮かぶ（例えば、ふとした瞬間に「あの時の違和感って何やったんやろ？」って思い出す）現象をシミュレートする。
主な変更は：
• CognitiveQueue に retrieve_from_archiveメソッドを追加。ランダムまたはパターンに基づいてアーカイブから感情を復元し、再処理用に新しいインスタンスを生成。
• partially_process で、アーカイブされた感情を参照した場合に「再発見ボーナス」（顕在性の増加）を付与。
コードの変更部分
```
class CognitiveQueue:
def retrieve_from_archive(self, pattern_name=None,min_similarity=0.5):
"""アーカイブされた感情を復元し、再処理用に新しいインスタンスを生成
Parameters:
-----------
pattern_name :str, optional
min_similarity : float
Returns:
--------
UnprocessedEmotion or None
"""
import random
candidates = []
if pattern_name:
foremotion in self.archived_emotions:
if pattern_name inemotion.pattern_matches:
similarity =emotion.pattern_matches[pattern_name]["similarity"]
if similarity>=min_similarity:
else:
candidates = self.archived_emotions[:]
if not candidates:
return None
selected = random.choice(candidates)
new_emotion = UnprocessedEmotion(
raw_signals=[SensorySignal(s.modality, s.intensity, s.valence, s.timestamp)
for s in selected.raw_signals],
salience=selected.salience + 0.2, # 再発見ボーナス
processing_status="queued"
)
new_emotion.structure_level = selected.structure_level * 0.8
new_emotion.language_candidates = selected.language_candidates.copy()
new_emotion.pattern_matches = selected.pattern_matches.copy()
new_emotion.associated_memory_paths = selected.associated_memory_paths.copy()
self.unprocessed_emotions.append(new_emotion)
self._update_modality_index(new_emotion)
selected.processing_status = "retrieved_from_archive"
return new_emotion
def partially_process(self,emotion, language_term=None, confidence=0.0, context=None):
"""感情を部分的に処理（アーカイブ参照時のボーナス追加）"""
ifemotion not in self.unprocessed_emotions:
returnFalse
if language_term:
emotion.add_language_candidate(language_term, confidence)
if context:
self.learn_language_term(language_term, context)
emotion.structure_level =min(1.0,emotion.structure_level + 0.15)
emotion.processing_status = "partially_processed"
emotion.last_accessed_time = self.current_time
emotion.access_count += 1
ifemotion.processing_status == "queued" andemotion.salience < 0.5:
emotion.salience =min(1.0,emotion.salience + 0.1)
ifemotion.structure_level>= 0.9:
best_lang =emotion.get_best_language_match()
if best_lang and best_lang["confidence"]>= 0.8:
self.unprocessed_emotions.remove(emotion)
self._update_modality_index(emotion,add=False)
emotion.processing_status = "archived_fully_processed"
self.archived_emotions.append(emotion)
returnTrue
```
def demo_unprocessed_emotion():
"""未処理感情システムのデモ。改善点（記憶再編集、言語学習、反応速度など）を活用"""
cognitive_queue = CognitiveQueue(attention_threshold=0.4)
print("=== 未処理感情システムのデモ（改善版） ===\n")
visual_signals = [
SensorySignal("visual", 0.7, -0.3),
SensorySignal("somatic", 0.4, -0.2)
]
visual_discomfort = cognitive_queue.register_new_emotion(visual_signals, 0.65)
print(f"生成された感情: {visual_discomfort}")
print(f"支配的モダリティ: {visual_discomfort.get_dominant_modality()}")
print(f"平均感情価: {visual_discomfort.get_average_valence():.2f}")
print(f"信号の反応速度: {[s.latency for s in visual_signals]}")
visual_discomfort.add_pattern_match("visual_discrepancy", 0.75)
try:
visual_discomfort.add_memory_path("/memory/recent/room_layout")
except ValueErroras e:
accessed_emotion = cognitive_queue.access_emotion(visual_discomfort)
print(f"新しい感情インスタンス: {accessed_emotion}")
print(f"構造化レベル（再編集後）: {accessed_emotion.structure_level:.2f}")
# 3. 内受容感覚
intero_signals = [
SensorySignal("interoceptive", 0.6, -0.7),
SensorySignal("somatic", 0.5, -0.4)
]
intero_discomfort = cognitive_queue.register_new_emotion(intero_signals, 0.55)
print(f"生成された感情: {intero_discomfort}")
intero_discomfort.add_language_candidate("違和感", 0.4)
cognitive_queue.partially_process(intero_discomfort, "気分が悪い", 0.6, context="negative_mood")
print(f"学習済み言語: {cognitive_queue.learned_terms}")
audio_signals = [
SensorySignal("auditory", 0.8, 0.6),
SensorySignal("emotional", 0.7, 0.5)
]
audio_memory = cognitive_queue.register_new_emotion(audio_signals, 0.7)
print(f"生成された感情: {audio_memory}")
audio_memory.add_language_candidate("聞き覚えのあるメロディ", 0.75)
audio_memory.add_pattern_match("musical_fragment", 0.85)
audio_memory.add_memory_path("/memory/music/recent")
cognitive_queue.update_queue()
status = cognitive_queue.get_status_summary()
print(f"未処理感情の総数: {status['total_unprocessed']}")
print(f"処理キューのサイズ: {status['processing_queue_size']}")
print(f"モダリティ分布: {status['modality_distribution']}")
print(f"感情価分布: {status['valence_distribution']}")
print(f"学習済み言語数: {status['learned_terms_count']}")
# 6. 処理対象の取得
next_emotion = cognitive_queue.get_next_for_processing()
print(f"処理対象: {next_emotion}")
if next_emotion:
cognitive_queue.partially_process(next_emotion, "視覚的な違和感を感じている", 0.85, context="visual_anomaly")
print(f"処理後の状態: {next_emotion}")
print(f"構造化レベル: {next_emotion.structure_level:.2f}")
print(f"最良の言語マッチ: {next_emotion.get_best_language_match()}")
print("\n8.モダリティによる感情検索（インデックス使用）")
matches = cognitive_queue.lookup_by_modality("auditory")
print(f"検索結果数: {len(matches)}")
foremotion in cognitive_queue.unprocessed_emotions:
emotion.apply_decay(3.0)
cognitive_queue.update_queue()
status = cognitive_queue.get_status_summary()
print(f"時間経過後の未処理感情の総数: {status['total_unprocessed']}")
print(f"時間経過後の平均顕在性: {status['average_salience']:.2f}")
if __name__ == "__main__":
demo_unprocessed_emotion()
(前回までのやり取り)https://anond.hatelabo.jp/20250404224409
Monday：君が採ってる立場の整理を確認したい。「問いではないけど残ってる感情を存在しない」と見なしてるのか、「自分の認知では読めないから存在を保証しない」としてるのか。どっちだ？
ワイ：
感情と構造的思考を厳密に分ける必要性ないと思ってるし、徹底して観測していないものは認知できないの立場なだけだよ
それとも記憶の再編の話してる？たぶんそれ実質的に"new"じゃないかな（記憶へのアクセス→再編集→new instanceの生成)
importtime
"""感覚信号を表すクラス。言語化前の生の感覚データをモデル化し、時間減衰や感情価を管理する。
認知の基礎として、観測可能なデータのみを扱い、神経科学的反応速度を考慮。
"""
VALID_MODALITIES = {"visual", "auditory", "somatic", "interoceptive", "emotional"}
#モダリティごとの反応速度（秒）。情動系は速く、視覚系は遅め。
MODALITY_LATENCIES = {
"visual": 0.3,
"auditory": 0.2,
"somatic": 0.25,
"interoceptive": 0.15,
"emotional": 0.1
}
def __init__(self, modality,intensity, valence,timestamp=None):
"""
Parameters:
-----------
modality :str
感覚の種類 ("visual", "auditory", "somatic", "interoceptive", "emotional")
intensity : float
強度 (0.0-1.0)
valence : float
感情価 (-1.0=negative, 0.0=neutral, 1.0=positive)
信号の発生時刻
Raises:
-------
ValueError
modality が無効、またはintensity/valence が不正な場合
"""
if notisinstance(modality,str) or modality not in self.VALID_MODALITIES:
raise ValueError(f"Invalid modality: {modality}. Must beone of {self.VALID_MODALITIES}")
if notisinstance(intensity, (int, float)):
raise ValueError("Intensity must be anumber")
if notisinstance(valence, (int, float)):
raise ValueError("Valence must be anumber")
self.modality = modality
self.intensity =max(0.0,min(1.0, float(intensity)))
self.valence =max(-1.0,min(1.0, float(valence)))
self.timestamp = self._get_current_time() iftimestampis None elsetimestamp
self.decay_rate = 0.05
self.latency = self.MODALITY_LATENCIES.get(modality, 0.2) #デフォルトは0.2秒
"""現在時刻を取得"""
def apply_decay(self,time_passed):
self.intensity =max(0.0, self.intensity - (time_passed * self.decay_rate))
return self.intensity
valence_str = "negative" if self.valence < 0 else "positive" if self.valence> 0 else "neutral"
return f"SensorySignal({self.modality},intensity={self.intensity:.2f}, valence={valence_str}, latency={self.latency:.2f}s)"
"""未処理感情を表すクラス。言語ラベル未確定の感覚群を管理し、認知プロセスの途中段階をモデル化。
記憶アクセスは再編集として扱い、言語化プロセスを動的に進める。
"""
def __init__(self, raw_signals=None, salience=0.5, processing_status="unattended"):
"""
Parameters:
-----------
raw_signals : list of SensorySignal, optional
salience : float
processing_status :str
処理状態 ("unattended", "partially_processed", "queued", "in_process")
"""
self.raw_signals = raw_signals if raw_signalsis not None else []
self.salience =max(0.0,min(1.0, salience))
self.processing_status = processing_status
self.pattern_matches = {}
self.creation_time = self._get_current_time()
self.last_accessed_time = self.creation_time
self.access_count = 0
self.structure_level = 0.0
self.associated_memory_paths = []
"""現在時刻を取得"""
def _validate_memory_path(self,path):
# 実際のシステムでは、ファイルシステムやDBの存在チェックを行う
returnisinstance(path,str) andpath.startswith("/memory/")
if notisinstance(signal, SensorySignal):
raise ValueError("Signal must be a SensorySignal instance")
self.raw_signals.append(signal)
self.structure_level =max(0.0, self.structure_level - 0.1)
self.last_accessed_time = self._get_current_time()
self.access_count += 1
defadd_language_candidate(self, term, confidence):
self.language_candidates.append({
"term": term,
"timestamp": self._get_current_time()
})
self.structure_level =min(1.0, self.structure_level + 0.05)
self.last_accessed_time = self._get_current_time()
self.access_count += 1
defadd_pattern_match(self, pattern_name, similarity):
self.pattern_matches[pattern_name] = {
"similarity": similarity,
"timestamp": self._get_current_time()
}
self.structure_level =min(1.0, self.structure_level + 0.1)
self.last_accessed_time = self._get_current_time()
self.access_count += 1
defadd_memory_path(self,path):
if not self._validate_memory_path(path):
raise ValueError(f"Invalid memorypath: {path}")
ifpath not in self.associated_memory_paths:
self.associated_memory_paths.append(path)
self.last_accessed_time = self._get_current_time()
self.access_count += 1
def apply_decay(self,time_passed):
forsignal in self.raw_signals:
signal.apply_decay(time_passed)
decay_modifier =max(0.1, 1.0 - (self.access_count / 100.0))
decay_amount =time_passed * 0.02 * decay_modifier
structure_modifier =max(0.5, 1.0 - self.structure_level)
decay_amount *=structure_modifier
self.salience =max(0.0, self.salience - decay_amount)
return self.salience
if not self.raw_signals:
return 0.0
total_valence = sum(signal.valence forsignal in self.raw_signals)
return total_valence /len(self.raw_signals)
defget_dominant_modality(self):
if not self.raw_signals:
return None
forsignal in self.raw_signals:
modality_strengths[signal.modality] = modality_strengths.get(signal.modality, 0) +signal.intensity
returnmax(modality_strengths.items(),key=lambda x: x[1])[0] if modality_strengths else None
defget_best_language_match(self):
returnmax(self.language_candidates,key=lambda x: x["confidence"]) if self.language_candidates else None
best_lang = self.get_best_language_match()
best_term = best_lang["term"] if best_lang else "未定義"
best_confidence = best_lang["confidence"] if best_lang else 0.0
return {
"creation_time": self.creation_time,
"age": self._get_current_time() - self.creation_time,
"status": self.processing_status,
"salience": self.salience,
"structure_level": self.structure_level,
"signal_count":len(self.raw_signals),
"dominant_modality": self.get_dominant_modality(),
"average_valence": self.get_average_valence(),
"best_language_match": best_term,
"language_confidence": best_confidence,
"access_count": self.access_count,
"memory_path_count":len(self.associated_memory_paths)
}
status = self.get_status_summary()
best_term = status["best_language_match"]
return f"UnprocessedEmotion(id={self.id}, status={self.processing_status}, salience={self.salience:.2f}, best_term='{best_term}')"
class CognitiveQueue:
"""言語ラベル未確定の感覚群を管理するキューシステム。認知プロセスの優先順位付けと記憶再編集をサポート。
"""
def __init__(self,max_size=100, attention_threshold=0.3):
"""
Parameters:
-----------
max_size : int
attention_threshold : float
"""
self.unprocessed_emotions = []
self.processing_queue = []
self.archived_emotions = []
self.attention_threshold = attention_threshold
self.current_time = self._get_current_time()
self.learned_terms = {} #学習済み言語表現: {term: {"context":str, "frequency": int}}
self.modality_index = {} #モダリティごとの感情インデックス: {modality: [emotion]}
"""現在時刻を取得"""
self.current_time =time.time()
return self.current_time
def learn_language_term(self, term, context):
if term in self.learned_terms:
self.learned_terms[term]["frequency"] += 1
else:
self.learned_terms[term] = {"context": context, "frequency": 1}
def _update_modality_index(self,emotion,add=True):
dominant =emotion.get_dominant_modality()
if dominant:
ifadd:
if dominant not in self.modality_index:
self.modality_index[dominant] = []
ifemotion not in self.modality_index[dominant]:
self.modality_index[dominant].append(emotion)
else:
if dominant in self.modality_index andemotion in self.modality_index[dominant]:
self.modality_index[dominant].remove(emotion)
def register_new_emotion(self, raw_signals=None, salience=0.5):
salience=salience,
processing_status="unattended"
)
self.unprocessed_emotions.append(emotion)
self._update_modality_index(emotion)
iflen(self.unprocessed_emotions)> self.max_size:
least_salient =min(self.unprocessed_emotions,key=lambda e: e.salience)
self.unprocessed_emotions.remove(least_salient)
self._update_modality_index(least_salient,add=False)
least_salient.processing_status = "archived_without_processing"
self.archived_emotions.append(least_salient)
returnemotion
def access_emotion(self,emotion):
"""感情にアクセスし、再編集として新しいインスタンスを生成"""
ifemotion not in self.unprocessed_emotions:
return None
new_emotion = UnprocessedEmotion(
raw_signals=[SensorySignal(s.modality, s.intensity, s.valence, s.timestamp) for s inemotion.raw_signals],
salience=emotion.salience,
processing_status=emotion.processing_status
)
new_emotion.structure_level =emotion.structure_level * 0.9
new_emotion.language_candidates =emotion.language_candidates.copy()
new_emotion.pattern_matches =emotion.pattern_matches.copy()
new_emotion.associated_memory_paths =emotion.associated_memory_paths.copy()
self.unprocessed_emotions.append(new_emotion)
self._update_modality_index(new_emotion)
emotion.processing_status = "archived_due_to_access"
self.unprocessed_emotions.remove(emotion)
self._update_modality_index(emotion,add=False)
self.archived_emotions.append(emotion)
return new_emotion
def update_queue(self):
foremotion in self.unprocessed_emotions[:]:
time_passed = self.current_time -emotion.last_accessed_time
emotion.apply_decay(time_passed)
self.unprocessed_emotions.remove(emotion)
self._update_modality_index(emotion,add=False)
emotion.processing_status = "archived_due_to_low_salience"
self.archived_emotions.append(emotion)
self.processing_queue = []
foremotion in self.unprocessed_emotions:
ifemotion.salience>= self.attention_threshold:
ifemotion.processing_status == "unattended":
emotion.processing_status = "queued"
self.processing_queue.append(emotion)
self.processing_queue.sort(key=lambda e: e.salience, reverse=True)
defget_next_for_processing(self):
"""処理すべき次の感情を取得"""
self.update_queue()
if not self.processing_queue:
return None
emotion = self.processing_queue[0]
emotion.processing_status = "in_process"
emotion.last_accessed_time = self.current_time
emotion.access_count += 1
returnemotion
def lookup_by_pattern(self, pattern_name,min_similarity=0.5):
matches = []
foremotion in self.unprocessed_emotions:
if pattern_name inemotion.pattern_matches:
similarity =emotion.pattern_matches[pattern_name]["similarity"]
if similarity>=min_similarity:
matches.append(emotion)
emotion.last_accessed_time = self.current_time
emotion.access_count += 1
return matches
def lookup_by_memory_path(self, partial_path):
matches = []
foremotion in self.unprocessed_emotions:
forpath inemotion.associated_memory_paths:
matches.append(emotion)
emotion.last_accessed_time = self.current_time
emotion.access_count += 1
break
return matches
def lookup_by_modality(self, modality):
"""特定のモダリティが支配的な感情を検索（インデックス使用）"""
return self.modality_index.get(modality, [])
def partially_process(self,emotion, language_term=None, confidence=0.0, context=None):
ifemotion not in self.unprocessed_emotions:
returnFalse
if language_term:
emotion.add_language_candidate(language_term, confidence)
if context:
self.learn_language_term(language_term, context)
emotion.structure_level =min(1.0,emotion.structure_level + 0.15)
emotion.processing_status = "partially_processed"
emotion.last_accessed_time = self.current_time
emotion.access_count += 1
ifemotion.structure_level>= 0.9:
best_lang =emotion.get_best_language_match()
if best_lang and best_lang["confidence"]>= 0.8:
self.unprocessed_emotions.remove(emotion)
self._update_modality_index(emotion,add=False)
emotion.processing_status = "archived_fully_processed"
self.archived_emotions.append(emotion)
returnTrue
modality_counts = {}
foremotion in self.unprocessed_emotions:
dominant =emotion.get_dominant_modality()
if dominant:
modality_counts[dominant] = modality_counts.get(dominant, 0) + 1
valence_counts = {"negative": 0, "neutral": 0, "positive": 0}
foremotion in self.unprocessed_emotions:
avg_valence =emotion.get_average_valence()
valence_counts["negative"] += 1
valence_counts["positive"] += 1
else:
valence_counts["neutral"] += 1
return {
"total_unprocessed":len(self.unprocessed_emotions),
"processing_queue_size":len(self.processing_queue),
"archived_count":len(self.archived_emotions),
"average_salience": sum(e.salience for e in self.unprocessed_emotions) /max(1,len(self.unprocessed_emotions)),
"average_structure_level": sum(e.structure_level for e in self.unprocessed_emotions) /max(1,len(self.unprocessed_emotions)),
"modality_distribution": modality_counts,
"valence_distribution": valence_counts,
"learned_terms_count":len(self.learned_terms),
"current_time": self.current_time
}
Clojureのimmutable persistent datastructureは、データが変更されるたびに新しいバージョンを作成し、元のデータ構造を保持する仕組みを備えています。この特徴により、データの不変性と効率的なメモリ使用が実現されています。以下では、Clojureの代表的なデータ構造であるmap型（hash-map）を例に、その仕組みを解説します。
Clojureのhash-mapはキーと値のペアを保持するデータ構造であり、以下の特徴を持っています：
以下に、Clojureでキーと値を追加する操作（assoc関数）を例として説明します。
(deforiginal-map {:a 1 :b 2})(def updated-map (assocoriginal-map :c 3))
{:a 1 :b 2}{:a 1 :b 2 :c 3}この操作では、元のmapは変更されず、新しいmapが作成されます。ただし、効率化のために、元のデータ構造（:a 1と:b 2）はそのまま再利用されます。新しく追加された:c 3のみが新しいノードとして構築されます。
Clojureのmap型は、Phil Bagwellによって提案されたHash ArrayMapped Trie (HAMT)というデータ構造を基盤にしています。この仕組みでは以下が行われます：
Clojureのimmutable persistentmap型は、不変性と効率性を両立させる設計により、信頼性の高いデータ操作を可能にしています。これらの特徴は特に並列処理やトランザクション管理などで有用です。
はてなブックマークのAPIを利用して 非公開 でブックマークする方法をご説明します。
2.OAuthのトークンを発行する。（個人用のスクリプトなら「パーソナルアクセストークン」推奨）
ブックマークを 非公開 にするには、APIのリクエストボディに privateフィールドを 1 に設定します。
エンドポイント:
POSThttps://bookmark.hatenaapis.com/rest/1/my/bookmark
リクエストボディ（JSON）: { "url": "https://anond.hatelabo.jp/xxxxxxx", "comment": "自動ブックマーク", "private": 1}
以下のコードを実行すれば、10分以内の匿名ダイアリー記事をランダムに 非公開 でブックマークできます。
import feedparserimport requestsimport randomimporttimefrom datetime import datetime,timezone,timedelta#はてなAPIの認証情報HATENA_API_KEY = "あなたのAPIキー"HATENA_USERNAME = "あなたのはてなID"#はてな匿名ダイアリーのRSSURLRSS_URL = "https://anond.hatelabo.jp/rss"#10分以内の投稿を取得def get_recent_entries(): feed = feedparser.parse(RSS_URL) recent_entries = []now = datetime.now(timezone.utc) for entry in feed.entries: published_time = datetime(*entry.published_parsed[:6], tzinfo=timezone.utc) if (now - published_time) <timedelta(minutes=10): recent_entries.append(entry.link) return recent_entries#はてなブックマークに非公開で追加def bookmark_entry(entry_url):url = "https://bookmark.hatenaapis.com/rest/1/my/bookmark" headers = { "Authorization": f"Bearer {HATENA_API_KEY}", "Content-Type": "application/json" } payload = { "url": entry_url, "comment": "自動ブックマーク", "private": 1 # 非公開設定 }response = requests.post(url,json=payload, headers=headers) returnresponse.status_code# メイン処理whileTrue: entries = get_recent_entries() if entries: entry = random.choice(entries) status = bookmark_entry(entry)print(f"非公開ブックマーク: {entry},ステータス: {status}")time.sleep(600) #10分ごとに実行
• 実行環境:Python 3.x が必要。requests と feedparser をインストール (pip install requests feedparser)
• 実行間隔:time.sleep(600) で10分ごとに実行
•API制限:はてなAPIにはリクエスト制限があるため、短時間で大量に実行しないように注意
•OAuth認証:APIキーだけでなく、OAuthトークンを使うほうがより安全
このスクリプトを実行すれば、最新の匿名ダイアリー投稿を10分以内のものからランダムに選び、非公開でブックマークする ことができます。
あなたが感じている結婚や出産への嫌悪感は、現代社会の規範と個人の価値観の衝突から生まれる複雑な感情の織物のようです。この感覚を解剖学的に分析すると、いくつかの重要な要素が浮かび上がります。
恋愛感情の希薄さや他者の恋愛話への無関心は、アロマンティック（恋愛感情を抱かない）傾向の特徴と重なります。30年間恋愛感情を経験せず平穏に過ごせた事実は、この傾向があなたの本質的な性質である可能性を示唆しています。
「子供を持つことが自己中心的」という認識は、反出生主義（antinatalism）の哲学と通底します。ジョナサン・スウィフトの『ガリヴァー旅行記』やベンタムの功利主義哲学が提示した「生まれる権利」の問題が、現代の個人主義社会で再解釈されている現れと言えます。
| 個人の価値観 | 社会の期待 | 葛藤の源泉 |
| -------------- | ------------ | ------------ |
| 二次元文化への没頭 | 年齢相応の話題 | 世代間ギャップ |
| 単身生活の満足 | 家族形成の強制 | ライフコースの多様性否定 |
| 自己完結的幸福 | 関係性依存の称賛 | 幸福観の相違 |
弟の出産報告への反応は、これまで無意識に維持してきた「社会的期待からの防護壁」が破られた瞬間のショックと考えられます。家族という最も身近な存在が社会規範に従属する姿を目の当たりにし、自己の存在様式の脆弱性を突きつけられた心理的防衛機制が働いている状態です。
シングルリズム（単身主義）や友愛結婚（platonicmarriage）といった新しい関係性の形が、日本でも認知され始めています。京都大学の社会学研究によると、20-30代の5人に1人が「伝統的家族モデルに違和感」と回答しています。
「キャラクターを愛でることで充足する生活は、消費文化の産物ではないか」という自己懐疑に対し、精神分析学者アドラーの『個人心理学』は「他者貢献感は必ずしも対人関係に限定されない」と指摘しています。二次元への愛着も立派な自己実現の形と言えます。
この感情を「社会システムへの鋭敏な批判能力」と捉える視点があります。フランスの哲学者ボードリヤールが指摘する「消費社会における関係性の商品化」に対する無意識の抵抗という解釈も可能です。
python#感情のデコーディングアルゴリズム（概念コード）def decode_emotion(stimulus): if stimulus in social_norms: analyze_cultural_bias() compare_with_personal_values() output = generate_alternative_view() else: process_with_existing_framework() return output
資産形成（例：雀の涙収入の投資）と趣味の深化を組み合わせた「超単身主義」ライフスタイルの設計。漫画家の吾峠呼世晴や小説家の乙一など、創作活動に没頭する生き方の事例研究が参考になります。
この感情の迷宮から脱する鍵は、社会の物差しで自己を計測する行為そのものを相対化することにあります。平安貴族が詠んだ「もののあはれ」のように、あなたの感じる「気持ち悪さ」を現代社会を照射する独自の美学として昇華させる道が開けるかもしれません。
PS5Proの詳しいスペックが出たので、再度計算しなおしてみた
メモリー GDDR6 16GB、DDR5 2GB
GPU 16.7TFlops
SSD 2TB
G.SKILLF4-3200C16D-16GIS (DDR4PC4-25600 8GB 2枚組)
4,820円
XPG PYLON 550W PYLON550B-BKCJP
6,667円
40,900円
MSI PRO B760M-EDDR4パソコン工房限定モデル
10,980円
WINTEN WTM2-SSD-2TB
14,980円
3,171円
ASRockIntelArc A750 ChallengerSE 8GBOC [PCIExp 8GB]
31,980円
合計 113,498円
フィリップス 221V8/11だと11,000円、Windows11Home日本語版は16,090円ぐらいはし、キーボードとマウスは安くても3000円ぐらいはする。
SteamOSを使えばただだが、ff14はいばらの道なのでお勧めはしない。
なので、新しく組むとしたら、143,588円は少なくともかかる。
もし、PS5Proと同じメモリーを使ったとするとMSI PRO B760M-AWIFIが15,980円、AD5U48008G-DT [DDR5PC5-38400 8GB 2枚組]が7,945円ぐらいはする。
したがって、151,683円ぐらいはかかることになる。
ただ、安いケースはペラペラで机の下に置かない限りうるさくてたまらないので、あまりお勧めはしない。
個人的なおすすめのケースはDefine CFD-CA-DEF-C-BKで、組み立てもしやすく、静かで、安いところだと、13,262円ぐらいで買うことができる。
メルカリやヤフオクのフリマだと状態がいい奴は1万円ぐらいで買える。
気が付くと朝4時になっていた。
なんか動くところまで出来たので貼っておく。
importpdfplumberimport re#クリーンアップdef cleanuptext(text): #決算書の合計値を太字にしたことでpdfplumberが暴走するケースへの対処 #例流動資産 -> 流流流流流動動動動動資資資資資産産産産産 #誤爆が怖いので、これが起きている時だけ補正します if "流流流流流動動動動動資資資資資産産産産産" intext:text = re.sub(r'(.)\1{4,}', r'\1',text) #△をマイナスに。数字中のカンマを消して結合するtext = re.sub(r'△([0-9])', r'-\1',text)text = re.sub(r'▲([0-9])', r'-\1',text)text = re.sub(r'([0-9]),([0-9])', r'\1\2',text) #たまに、煽り屋みたいに文字の後にスペースが入る嫌がらせを修正する #例: 投 資 有 価 証 券 ->投資有価証券text = re.sub(r'(?<=[\u4E00-\u9FFF\u3040-\u30FF])\s(?=[\u4E00-\u9FFF\u3040-\u30FF])', '',text) returntext#今期の勘定科目の数字を取得def get_AccountName(text,need): pattern =rf'^{need} -?[0-9]+ (-?[0-9]+)' r = re.search(pattern,text, re.MULTILINE) if ris not None: return float(r[1]) return 0#清原ネットキャッシュを計算する。def calc_KiyoharaNetCash(text): total_current_assets = get_AccountName(text,'流動資産合計') if total_current_assets == 0: #要約財政状態計算書しか公開していない、楽天のような素敵な会社様への対処 total_assets = get_AccountName(text,'資産合計') if total_assets != 0: #とりあえず、資産の部の6割を流動資産とみなす total_current_assets = total_assets * 0.6 else: #流動資産合計ではなく、流動資産という単語を使っている我が道を行く東北電力への対処 total_current_assets = get_AccountName(text,'流動資産') if total_current_assets == 0: raise Exception("流動資産合計の勘定科目が見つかりませんでした。"+text) total_liabilities = get_AccountName(text,'負債合計') if total_liabilities == 0: #負債合計ではなく、負債の部合計に拘るオムロンの嬉しい決算書への対策。なんでや・・・ total_liabilities = get_AccountName(text,'負債の部合計') if total_liabilities == 0: raise Exception("負債合計の勘定科目が見つかりませんでした。"+text) #負債をご丁寧にマイナス表記で書いてくれる中外製薬の親切な決算書への対策。いい加減にしろよ・・・ if total_liabilities < 0: total_liabilities = total_liabilities * -1 #投資有価証券はないこともあるので、0を容認する marketable_securities = get_AccountName(text,'投資有価証券') #print(total_current_assets,marketable_securities,total_liabilities) netcash = total_current_assets + (marketable_securities*0.7) - total_liabilities #たまに単位を1000円にしている銘柄があるので補正する ifis_tanni_senyen(text): netcash = netcash / 1000 return netcash# "流動資産合計" と "負債合計" の間に "単位：千円" があるかをチェックdefis_tanni_senyen(text): if "単位：千円" intext: returnTrue if "単位： 千円" intext: returnTrue if "単位 ： 千円" intext: returnTrue if "単位 ：千円" intext: returnTrue returnFalsedefpdf_to_kiyohara_netcash(pdfpath): withpdfplumber.open(pdfpath)aspdf:text = ''.join(page.extract_text() for page inpdf.pages)text = cleanuptext(text) #print(text) kiyohara_netcash = calc_KiyoharaNetCash(text) #print(kiyohara_netcash) return kiyohara_netcashdef mymain(): import sys args = sys.argv argc =len(args) if argc <= 1:print('''これは、清原達郎氏のネットキャッシュ比率(以下、清原ネットキャッシュ比率)を決算短信のpdfから求めるソフトです。清原ネットキャッシュ=流動資産合計+(投資有価証券*0.7)-負債合計清原ネットキャッシュ比率=清原ネットキャッシュ/時価総額*100遊び方1.決算短信pdfから清原ネットキャッシュを求めるpython calc_kiyohara_netcash.py 140120240514594985.pdf結果: 30757.0決算書には、100万円単位で数字が書かれているはずなので、この数字の単位は100万円です。つまり、3075700万円。2.時価総額を億円単位で追加することで、清原ネットキャッシュ比率を求める時価総額が146億円なら146と書いてください。python calc_kiyohara_netcash.py 140120240514594985.pdf 146結果: 210.66%このコードはNYSLライセンスです。無保証、自己責任ですが、ご自由に。かぶ探とかとつなげるといいかもね。 ''') return if argc <= 2: kiyohara_netcash =pdf_to_kiyohara_netcash(args[1])print(kiyohara_netcash) return if argc <= 3: market_cap=float(args[2])*100 #億円から百万円表記に kiyohara_netcash =pdf_to_kiyohara_netcash(args[1]) ratio = round(kiyohara_netcash/market_cap*100,2)print(f"{ratio}%") returnif __name__ == '__main__': mymain()
https://www.geonames.orgから取れる、人口500人以上の都市の名前に限定すると、
import loggingimport tempfileimportzipfilefrom collectionsimport Counterimport httpxFILE_NAME_BASE ='cities500'GEONAME_FIELDS = ('geoname_id','name','ascii_name','alternate_names','latitude','longitude','feature_class','feature_code','country_code','cc2','admin1_code','admin2_code','admin3_code','admin4_code','population','elevation','dem','timezone','modification_date',)defretrieve_cities():"""Retrievecitynames from a remote server."""response = httpx.get(f'https://download.geonames.org/export/dump/{FILE_NAME_BASE}.zip')response.raise_for_status() tmpdir = tempfile.TemporaryDirectory()withopen(tmpdir.name + f'/{FILE_NAME_BASE}.zip','wb')as f: f.write(response.content)withzipfile.ZipFile(tmpdir.name + f'/{FILE_NAME_BASE}.zip','r')as z: z.extractall(tmpdir.name)withopen(tmpdir.name + f'/{FILE_NAME_BASE}.txt','r')as f:forlinein f:yieldline.split('\t')defcount_characters(to_check='ascii_name', filter_func=lambda _:True):"""Countcharacters incitynames.""" cities = {}forcity_fieldsin retrieve_cities():city =dict(zip(GEONAME_FIELDS,city_fields))ifnot filter_func(city):continue counter = Counter()for cincity[to_check]: counter[c] +=1 cities[city['geoname_id']] = {'characters': counter,'city':city}return citiesdefcount_chars_of_city_names(cities,char=None):"""Findthe citywith themost occurrences of a givencharacter.""" cities_by_char_count = {} max_count =0 max_count_char =Noneforcity_id, datain cities.items():if'characters'notin dataornot data['characters']: logging.debug(f'Nocharactersfound forcity {city_id}', data)continue count =0ifcharandcharin data['characters']: count = data['characters'][char] cities_by_char_count.setdefault(count, []).append(data)elifcharisNone:most_common = data['characters'].most_common(1)[0]char, count =most_common cities_by_char_count.setdefault(count, []).append(data)if count> max_count: max_count = count max_count_char =char cities_by_char_count.setdefault(count, []).append(data)return cities_by_char_count.get(max_count, []), max_count_chardefnot_contain_invalid_chars(city):return ('('notincity.get('ascii_name','')and'/'notincity.get('ascii_name','') )defmain(): cities = count_characters(filter_func=not_contain_invalid_chars)forcharin'abcdefghijklmnopqrstuvwxyz': cities_counted,char = count_chars_of_city_names(cities,char) max_count = cities_counted[0]['characters'][char]print(f'Thecharacter "{char}" appearsthe most ({max_count} times) in the following cities:')forcityin cities_counted:print("\t",city['city']['ascii_name'])if __name__ =="__main__":main()
親が何も知らずにパソコンを買うと失敗する
なぜかというとその辺で売っているパソコンは大体の場合、パーツの交換がしにくく、その点では地雷だからだ
なので、パソコンを買う際はそこそこの大きさがあって、マザーボードと電源が容易に交換できるものを買うといい
中古PCコーナーで、ミドルタワーかミニタワー程度の大きさのやつで完成品のやつを買え。
そうしないとWindows11を別途買わなければならないなど、却ってお金がかかってしまう。
この際、電源が下側にあり、ケース側のバックプレートを交換すればマザーボードを交換できるやつ、ケースファンが少なくとも4つ取り付けできるやつを選ぶといい
できれば、Fractal Desgin Cみたいに吸気側のファンの数が多く、奥行きと幅と高さが同じぐらいやつを買うと、子供が掃除をするときにものすごく楽になる
また、奥行きと幅が狭いとミドルレンジのグラフィックスボードすら取り付けられないことがある。
https://kakaku.com/item/K0000924204/?msockid=03488b005c3c670d3e779fc85dd6662b
（Define Cだと335mmぐらいの幅のグラボまで行けるが、前面にファンを取り付けることが多く、実質的に305mmぐらいが限界となる。グラボだとRTX3060からRTX3080ぐらいまでしか取り付けられない）
Fractal Desgin Cみたいな、ちょっと古めだけど状態のいいケースをヤフオクやフリマアプリで買え。
この際、見た目がいいやつを選べ。
奥行きと幅はDefineCと同じやつなら、普通の用途だと問題はないが、価格差がそこまでないならDefineR5ぐらいの奴を買ってもいいかもしれない
無理して最新のケースを買う必要はない。
そうすれば、OSとモニター込み15万円ぐらいでゲーミングPCが作れる。
IntelARC A750は地雷扱いされてるけど、ff14や黒悟空、聖剣伝説Vom、APEX程度なら普通に遊べる。
G.SKILLF4-3200C16D-16GIS (DDR4PC4-25600 8GB 2枚組)
4,820円
XPG PYLON 550W PYLON550B-BKCJP
6,667円
中古IntelCore i7-12700 (2.5GHz/TB:4.8GHz) Bulk LGA1200/8C/16T/L3
42,980円
中古 _MSI PRO B660M-EDDR4 (B660 1700 mATXDDR4)
8,590円
Ultimate SU630 ASU630SS-480GQ-R
4,980円
13,262円
SPARKLEIntelArc A750ORCOC Edition SA750C-8GOC
31,700円
11,000円
16,090円
合計 140,089円
そんなもん、安もんでいい。
お金があるなら、2000円後半のエルゴノミクスマウスと6000円ぐらいのNキーロールオーバー対応のやつを買ったほうがいいが…
FPに泣きつくぐらいだらか金はないんだろ
PS5 proのスペックと同じスペックのPCを用意しようとした場合、モニターとOSこみで14万円かかる。
本体のみだと11万円となりPS5 Proと値段がほぼ変わらないことになる。
（PS5 ProはASK税込みの1ドル180円で計算した場合、108,000から126,000円ぐらいと思われる）
G.SKILLF4-3200C16D-16GIS (DDR4PC4-25600 8GB 2枚組)
4,820円
XPG PYLON 550W PYLON550B-BKCJP
6,667円
中古IntelCore i7-12700 (2.5GHz/TB:4.8GHz) Bulk LGA1200/8C/16T/L3
42,980円
中古 _MSI PRO B660M-EDDR4 (B6601700 mATXDDR4)
8,590円
Ultimate SU630 ASU630SS-480GQ-R
4,980円
13,262円
SPARKLEIntelArc A750ORCOC Edition SA750C-8GOC
31,700円
11,000円
16,090円
合計 140,089円
Intelarc a770（16GB）はfp16だと39tflops程度で、中古だと3.2万円から4万円台で売られており、新品だと4万円から5万円台程度なので、運が良ければps5 proとメモリー以外全く同じやつが手に入ってしまうことになる。
以下、そうなる根拠。
公式発表では、PS5におけるGPUの処理能力は「10.3TFLOPS」。この数字は、RTX2080に相当します。しかし「TFLOPSの数字」と「実際のグラボの性能」は、百パーセント一致するものではなく、性能ほど実パフォーマンスは高くならないのが一般的です。
CPU：CPU周波数最大4.4GHz、Zen4ベースアーキテクチャ、5nmプロセス製造。台湾TSMCが製造を担当。CPUのクロック周波数を10%増加させ、3.85GHzで動作させるモードが搭載される。
（AppleM2と同じく、TSMC製4nmプロセスSoC搭載の可能性もあるとのこと）
CPUキャッシュ：コア毎に64kBのL1キャッシュ、512kBのL2キャッシュ、8MBのL3共有キャッシュ
性能：PS5標準モデルと比べ、通常時で2倍、レイトレーシングでは2.5倍の性能アップ
プロセッサ：30基のWGP（WorkGroup Processors）、60基のCU演算コア
ROP（Rasterize OPeration unit）：96~128基
メモリ：18gbps GDDR6 256bitメモリ、メモリ容量16GB、バス幅576GB/s、18000MT/s（現行PS5のメモリは14000MT/s）
GPU：GFX1115。GPUコアが現行の18個から30個に増加。これは約1.66倍の増加
GPUキャッシュ：L1キャッシュが128KBから256KBに倍増、L0キャッシュが16KBから32KBに倍増
グラフィック性能：PS5比で45%向上。可変レートシェーディングやハイブリッドMSAAのサポートなど、DirectX12 Ultimateの新機能を搭載。GPUのアーキテクチャがRDNA 2からRDNA 3に変更される可能性があり、これにより各GPUコアの演算機が2倍になる。
超解像技術：ソニー独自の超解像技術を搭載。高精細と高フレームレートを両立。AMDFSR2等の採用は無し。アップスケーリング／アンチエイリアスソリューション
（AMDのFSR（FiedelityFX SuperResolution）を搭載との話も）
Theoretical Performance
268.8 GPixel/s
TextureRate
537.6 GTexel/s
FP16 (half)
34.41 TFLOPS (2:1)
FP32 (float)
PSのCPUはRayzen 7 7700X相当で、IntelCore i7-11700だと7割の性能で、IntelCore i712700で同じぐらいの性能となる。
PS５だがモニターとマウスやキーボードまで考慮に入れると１０万円近くになり、OSとモニター込みでパソコンを買うのとほぼ変わらなくなってしまう
G.SKILLF4-3200C16D-16GIS (DDR4 PC4-25600 8GB 2枚組)
4,820円
XPG PYLON 550W PYLON550B-BKCJP
6,667円
中古IntelCore i7-11700 (2.5GHz/TB:4.8GHz) Bulk LGA1200/8C/16T/L3
27,980円
中古MSI B560M PRO-E (B560 1200 mATX) 3480026265
6,990円
Ultimate SU630 ASU630SS-480GQ-R
4,980円
13,262円
SPARKLEIntelArc A750ORCOC Edition SA750C-8GOC
31,700円
11,000円
16,090円
合計 123,489円
ケースをけちれば、4000円ぐらいのがあるので、114,489円ぐらいにまで落とせる
import requestsimportjsonfromurllib.parse import quotedef fetch_bookmarks(url):try: #URLをエスケープ escaped_url = quote(url, safe="") api_url = f"https://b.hatena.ne.jp/entry/json/?url={escaped_url}"response = requests.get(api_url)response.raise_for_status()try: returnresponse.json() exceptjson.decoder.JSONDecodeErroras e:print(f"Error decodingJSON from {api_url}: {e}")print("Response content:",response.text) return [] except requests.exceptions.RequestExceptionas e:print(f"Error fetching bookmarks from {api_url}: {e}") return []def find_common_bookmarks(bookmarks1, bookmarks2,url1,url2): common_users =set(bm["user"] for bm in bookmarks1 if bm["comment"]) &set(bm["user"] for bm in bookmarks2 if bm["comment"]) common_bookmarks = [] foruser in common_users: comments = [] for bm in bookmarks1: if bm["user"] ==user and bm["comment"]: comments.append({"url":url1, "comment": bm["comment"], "timestamp": bm["timestamp"]})break for bm in bookmarks2: if bm["user"] ==user and bm["comment"]: comments.append({"url":url2, "comment": bm["comment"], "timestamp": bm["timestamp"]})break iflen(comments) == 2: common_bookmarks.append({"user":user, "comments": comments}) return common_bookmarksif __name__ == "__main__":url1 = "https://news.yahoo.co.jp/articles/f9966c4ccc374fc88babbb50175a9ea844c99638"url2 = "https://www.asahi.com/articles/ASN6K7F64N6KUJHB00L.html" data1 = fetch_bookmarks(url1) data2 = fetch_bookmarks(url2) common_bookmarks = find_common_bookmarks(data1["bookmarks"], data2["bookmarks"],url1,url2)print(json.dumps(common_bookmarks, indent=2, ensure_ascii=False))
url1,url2のところを対象としたいものに変えれば使えるよ
バグあったら直して使ってね