常連

閲覧ありがとうございます。Python３でmatplotlibを用いてグラフを表示させたいのですが表示されなくて困っています。
各種サイトで検索かけて調べたのですが改善されないので詳しい方、教えていただけると助かります。plt.savefig（）は正常に動作しておりグラフが保存されているため計算部分にミスはないと思われます。

### 発生している問題・エラーメッセージ

```
グラフが表示されない
plt.show() が動いていない。
```

### 該当のソースコード

python3

T = Trange

plt.figure()
plt.plot(T, E, 'rx-')
plt.xlabel(r'Temperature $(\frac{J}{k_B})$')
plt.ylabel(r'$\langle E \rangle$ per site $(J)$')
plt.savefig("E8.pdf", format='pdf', bbox_inches='tight')

plt.figure()
plt.plot(T, SpcH, 'kx-')
plt.xlabel(r'Temperature $(\frac{J}{k_B})$')
plt.ylabel(r'$C_V$ per site $(\frac{J^2}{k_B^2})$')
plt.savefig("Cv8.pdf", format='pdf', bbox_inches='tight')

plt.figure()
plt.plot(T, M, 'bx-')
plt.xlabel(r'Temperature $(\frac{J}{k_B})$')
plt.ylabel(r'$\langle|M|\rangle$ per site $(\mu)$')
plt.savefig("M8.pdf", format='pdf', bbox_inches='tight')

plt.figure()
plt.plot(T, M_sus, 'gx-')
plt.xlabel(r'Temperature $(\frac{J}{k_B})$')
plt.ylabel(r'$\chi$ $(\frac{\mu}{k_B})$')
plt.savefig("chi8.pdf", format='pdf', bbox_inches='tight')

plt.tight_layout()
fig = plt.gcf()
plt.show()

np.savetxt('output.data',np.c_[T,E,SpcH,M,M_sus])
```

### 試したこと

ここに問題に対して試したことを記載してください。

### 補足情報（FW/ツールのバージョンなど）

```

```python
import matplotlib
matplotlib.use('Agg')
import numpy as np
from numpy import linalg as LA
import matplotlib.pyplot as plt

L = 8
ESTEP = 1000
STEP = 10000

J = 1 # J>0 to make it ferromagnetic

# Intitialize the XY network
def Init():
    return np.random.rand(L, L)*2*np.pi
    #return np.ones([L, L])

# periodic neighbor
def next(x):
    if x == L-1:
        return 0
    else:
        return x+1

# construct the bond lattice
def FreezeBonds(Ising,T,S):
    iBondFrozen = np.zeros([L,L],dtype=int)
    jBondFrozen = np.zeros([L,L],dtype=int)
    for i in np.arange(L):
        for j in np.arange(L):
            freezProb_nexti = 1 - np.exp(-2 * J * S[i][j] * S[next(i)][j] / T)
            freezProb_nextj = 1 - np.exp(-2 * J * S[i][j] * S[i][next(j)] / T)
            if (Ising[i][j] == Ising[next(i)][j]) and (np.random.rand() < freezProb_nexti):
                iBondFrozen[i][j] = 1
            if (Ising[i][j] == Ising[i][next(j)]) and (np.random.rand() < freezProb_nextj):
                jBondFrozen[i][j] = 1
    return iBondFrozen, jBondFrozen

# H-K algorithm to identify clusters
def properlabel(prp_label,i):
    while prp_label[i] != i:
        i = prp_label[i]
    return i

# Swendsen-Wang cluster
def clusterfind(iBondFrozen,jBondFrozen):
    cluster = np.zeros([L, L],dtype=int)
    prp_label = np.zeros(L**2,dtype=int)
    label = 0
    for i in np.arange(L):
        for j in np.arange(L):
            bonds = 0
            ibonds = np.zeros(4,dtype=int)
            jbonds = np.zeros(4,dtype=int)

            # check to (i-1,j)
            if (i > 0) and iBondFrozen[i-1][j]:
                ibonds[bonds] = i-1
                jbonds[bonds] = j
                bonds += 1
            # (i,j) at i edge, check to (i+1,j)
            if (i == L-1) and iBondFrozen[i][j]:
                ibonds[bonds] = 0
                jbonds[bonds] = j
                bonds += 1
            # check to (i,j-1)
            if (j > 0) and jBondFrozen[i][j-1]:
                ibonds[bonds] = i
                jbonds[bonds] = j-1
                bonds += 1
            # (i,j) at j edge, check to (i,j+1)
            if (j == L-1) and jBondFrozen[i][j]:
                ibonds[bonds] = i
                jbonds[bonds] = 0
                bonds += 1

            # check and label clusters
            if bonds == 0:
                cluster[i][j] = label
                prp_label[label] = label
                label += 1
            else:
                minlabel = label
                for b in np.arange(bonds):
                    plabel = properlabel(prp_label,cluster[ibonds[b]][jbonds[b]])
                    if minlabel > plabel:
                        minlabel = plabel

                cluster[i][j] = minlabel
                # link to the previous labels
                for b in np.arange(bonds):
                    plabel_n = cluster[ibonds[b]][jbonds[b]]
                    prp_label[plabel_n] = minlabel
                    # re-set the labels on connected sites
                    cluster[ibonds[b]][jbonds[b]] = minlabel
    return cluster, prp_label

# flip the cluster spins
def flipCluster(Ising,cluster,prp_label):
    for i in np.arange(L):
        for j in np.arange(L):
            # relabel all the cluster labels with the right ones
            cluster[i][j] = properlabel(prp_label,cluster[i][j])
    sNewChosen = np.zeros(L**2)
    sNew = np.zeros(L**2)
    flips = 0 # get the number of flipped spins to calculate the Endiff and Magdiff
    for i in np.arange(L):
        for j in np.arange(L):
            label = cluster[i][j]
            randn = np.random.rand()
            # mark the flipped label, use this label to flip all the cluster elements with this label
            if (not sNewChosen[label]) and randn < 0.5:
                sNew[label] = +1
                sNewChosen[label] = True
            elif (not sNewChosen[label]) and randn >= 0.5:
                sNew[label] = -1
                sNewChosen[label] = True

            if Ising[i][j] != sNew[label]:
                Ising[i][j] = sNew[label]
                flips += 1

    return Ising,flips

# Swendsen-Wang Algorithm in Ising model (with coupling constant dependency on sites)
# One-step for Ising
def oneMCstepIsing(Ising, S):
    [iBondFrozen, jBondFrozen] = FreezeBonds(Ising, T, S)
    [SWcluster, prp_label] = clusterfind(iBondFrozen, jBondFrozen)
    [Ising, flips] = flipCluster(Ising, SWcluster, prp_label)
    return Ising

# Decompose XY network to two Ising networks with project direction proj
def decompose(XY,proj):
    x = np.cos(XY)
    y = np.sin(XY)
    x_rot = np.multiply(x,np.cos(proj))+np.multiply(y,np.sin(proj))
    y_rot = -np.multiply(x,np.sin(proj))+np.multiply(y,np.cos(proj))
    Isingx = np.sign(x_rot)
    Isingy = np.sign(y_rot)
    S_x = np.absolute(x_rot)
    S_y = np.absolute(y_rot)
    return Isingx, Isingy, S_x, S_y

# Compose two Ising networks to XY network
def compose(Isingx_new,Isingy_new,proj,S_x, S_y):
    x_rot_new = np.multiply(Isingx_new,S_x)
    y_rot_new = np.multiply(Isingy_new,S_y)
    x_new = np.multiply(x_rot_new,np.cos(proj))-np.multiply(y_rot_new,np.sin(proj))
    y_new = np.multiply(x_rot_new,np.sin(proj))+np.multiply(y_rot_new,np.cos(proj))
    XY_new = np.arctan2(y_new,x_new)
    return XY_new

def oneMCstepXY(XY):
    proj = np.random.rand()
    [Isingx, Isingy, S_x, S_y] = decompose(XY, proj)
    Isingx_new = oneMCstepIsing(Isingx, S_x)
    #Isingy_new = oneMCstepIsing(Isingy, S_y)
    # Here we only use the flopping of Ising in projection direction, without the perpendicular direction
    #XY_new = compose(Isingx_new, Isingy_new, proj, S_x, S_y)
    XY_new = compose(Isingx_new, Isingy, proj, S_x, S_y)
    return XY_new

# Calculate the energy for XY network
def EnMag(XY):
    energy = 0
    for i in np.arange(L):
        for j in np.arange(L):
            # energy
            energy = energy - (np.cos(XY[i][j]-XY[(i-1)%L][j])+np.cos(XY[i][j]-XY[(i+1)%L][j])+np.cos(XY[i][j]-XY[i][(j-1)%L])+np.cos(XY[i][j]-XY[i][(j+1)%L]))
    magx = np.sum(np.cos(XY))
    magy = np.sum(np.sin(XY))
    mag = np.array([magx,magy])
    return energy * 0.5, LA.norm(mag)/(L**2)

# Swendsen Wang method for XY model
def SWang(T):
    XY = Init()
    # thermal steps to get the equilibrium
    for step in np.arange(ESTEP):
        XY = oneMCstepXY(XY)
    # finish with thermal equilibrium, and begin to calc observables
    E_sum = 0
    M_sum = 0
    Esq_sum = 0
    Msq_sum = 0
    for step in np.arange(STEP):
        XY = oneMCstepXY(XY)
        [E,M] = EnMag(XY)

        E_sum += E
        M_sum += M
        Esq_sum += E**2
        Msq_sum += M**2

    E_mean = E_sum/STEP/(L**2)
    M_mean = M_sum/STEP
    Esq_mean = Esq_sum/STEP/(L**4)
    Msq_mean = Msq_sum/STEP

    return XY, E_mean, M_mean, Esq_mean, Msq_mean

M = np.array([])fig = plt.gcf()
E = np.array([])
M_sus = np.array([])
SpcH = np.array([])
Trange = np.linspace(0.1, 2.5, 10)
for T in Trange:
    [Ising, E_mean, M_mean, Esq_mean, Msq_mean] = SWang(T)
    M = np.append(M, np.abs(M_mean))
    E = np.append(E, E_mean)
    M_sus = np.append(M_sus, 1/T*(Msq_mean-M_mean**2))
    SpcH = np.append(SpcH, 1/T**2*(Esq_mean-E_mean**2))

# plot the figures
T = Trange

plt.figure()
plt.plot(T, E, 'rx-')
plt.xlabel(r'Temperature $(\frac{J}{k_B})$')
plt.ylabel(r'$\langle E \rangle$ per site $(J)$')
plt.savefig("E8.pdf", format='pdf', bbox_inches='tight')

plt.figure()
plt.plot(T, SpcH, 'kx-')
plt.xlabel(r'Temperature $(\frac{J}{k_B})$')
plt.ylabel(r'$C_V$ per site $(\frac{J^2}{k_B^2})$')
plt.savefig("Cv8.pdf", format='pdf', bbox_inches='tight')

plt.figure()
plt.plot(T, M, 'bx-')
plt.xlabel(r'Temperature $(\frac{J}{k_B})$')
plt.ylabel(r'$\langle|M|\rangle$ per site $(\mu)$')
plt.savefig("M8.pdf", format='pdf', bbox_inches='tight')

plt.figure()
plt.plot(T, M_sus, 'gx-')
plt.xlabel(r'Temperature $(\frac{J}{k_B})$')
plt.ylabel(r'$\chi$ $(\frac{\mu}{k_B})$')
plt.savefig("chi8.pdf", format='pdf', bbox_inches='tight')

plt.tight_layout()
fig = plt.gcf()
plt.show()

np.savetxt('output.data',np.c_[T,E,SpcH,M,M_sus])


```

python matplotlib グラフが表示されない

### 実現したいこと

2つのグラフがあり、その交点をプロットしたい。例えば、y=cos xとy=cos(π cos x)の交点を自動的にもとめて、プロットしたいです。
交点の座標は簡単には求められないものです。

### 前提

y=cos xとy=cos(π cos x)の交点を自動的に算出して、プロットするようなプログラムを書きたい。Pythonで無理なら、別の言語でも大丈夫です。

np.argwhereを使ってみたものの、xの値はnp.linspaceなどで離散的に取得するので、交点となる無理数の解はリストの中に入らないため、プロットされない。

一方で、absなどで丸め誤差を利用するも、2つのグラフが接近する部分で無駄な部分にプロットされる。

そのため、複雑なグラフでは別のアプローチをとるべきなのかなと思いましたが、当方初心者で何もわかりません。調べてみたものの何もヒットしませんでしたので、ここで質問させてください。

今までは、LaTeXでグラフを書いていたのですが、LaTeXでは自動的にグラフの交点を算出するコマンドがありました。しかし、LaTeXでは複雑なグラフを書くことができず、matplotlibを使おうと思って、最近Pythonを学習し始めました。

### 発生している問題・エラーメッセージ

xの値はnp.linspaceなどで離散的に取得するので、交点となる無理数の解はリストの中に入らない。

absなどで丸め誤差を利用するも、2つのグラフが接近する部分で無駄な部分にプロットされる。

そのため、別のアプローチで交点を求めることが必要？


### 該当のソースコード

```Python
import matplotlib.pyplot as plt
import numpy as np

N = 99
x_min = 0
x_max = 2 * np.pi

def f(x):
    return np.cos(x)

def g(x):
    return np.cos(np.pi * f(x))

x = np.linspace(x_min, x_max, N)
y1 = f(x)
y2 = g(x)

idx = np.argwhere(np.sign(y1 - y2) == 0)

plt.plot(x[idx], y1[idx],'.', markersize=8)

plt.plot(x, y1)
plt.plot(x, y2)

plt.show()
```
![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2023-05-19/7a922e6a-1b7b-42ca-8963-b6ca83f10f3c.png)

### 試したこと

・Nの数を増やしてみたものの、交点の数は増えない。
・absを使って丸め誤差を利用するも、不要な点がプロットされてしまう。

### 補足情報（FW/ツールのバージョンなど）

VS codeを使用


【python】【至急】2つのグラフの交点をプロットする

### 実現したいこと・前提
**・X軸のレイアウトについて**
matplotlibのsubplotを用いて、6行2列（計12個）の時系列グラフを作成しております。
それぞれ時系列グラフなので、X軸には日付が出力されます。
YYYY-MM-ddと表示されるのですが、重なってしまい見づらくなってしまうので改善したいです。

![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2023-03-28/524ab9d6-13e5-4def-bcf2-9ac21bb3f27d.png)

**・出力サイズについて**
6行2列のグラフサイズはそれぞれ、figsize = (15, 50)になっています。
それをsavefigでPDF出力し、更にそれを紙（A4）で印刷します。
それが試行錯誤しても良い感じ？に印刷することができません。
具体的には、1列目のY軸ラベルが表示されなくなったり、
一番下に表示される日付が表示されなくなったりしてしまいます。

これらをある程度、綺麗に印刷できるようにご教示頂きたいです。
宜しくお願い致します。



### 現在のソースコード

```Python
fig = plt.figure(figsize = (15, 50), tight_layout=True)  # グラフサイズ(幅、高さ)
for col in range(df_1.shape[1]):
    plt.subplot(12, 2, col+1)
    plt.plot(df_1.iloc[:, col], marker="o", color="lime")
    # plt.title("No." + str(col))  # 列Noをタイトル
    plt.ticklabel_format(style="plain", axis="y", scilimits=(0, 0))  # eを使わない表現
    plt.gca().get_yaxis().set_major_formatter(ticker.FuncFormatter(lambda v,p: f'{int(v):,d}'))  # 3桁ごとにカンマで区切る
    plt.grid()

    # 列毎（各グラフ）の個別設定
    for i in range(len(columns)):
        if col == i:
            plt.title(columns[i])
            plt.legend([columns[i]])
            
plt.savefig(str_today + "sample.pdf")
```

### 試したこと

figsizeの変更、tight_layoutをやめて個別に設定

### 補足情報（FW/ツールのバージョンなど）
matplotlib                3.6.3



Matplotlib：時系列グラフでX軸のレイアウトと出力サイズについて

### 実現したいこと

ここに実現したいことを箇条書きで書いてください。
- [ ] > backtrader（バックテスト）に、注文を反映させたい。

### 前提

エントリーロジックには、以下のように単純なものしか記載していないのですが、
バックテストを行うと、一切エントリーがされていない状態となっています。

### 
        self.buy()
        elif self.position:
            self.sell()
```
実行後：
Final Portfolio Value: 100000.0
Sharpe Ratio: None
Max Drawdown: 0.0
Annual Return: OrderedDict([(datetime.datetime(2020, 2, 26, 23, 25), 0.0)])
Sharpe Ratio Analysis: OrderedDict([('sharperatio', None)])
Drawdown Analysis: AutoOrderedDict([('len', 0), ('drawdown', 0.0), ('moneydown', 0.0), ('max', AutoOrderedDict([('len', 0.0), ('drawdown', 0.0), ('moneydown', 0.0)]))])
Annual Return Analysis: OrderedDict([(datetime.datetime(2020, 2, 26, 23, 25), 0.0)])
```

### 該当のソースコード

```python

class PandasDataFeed(btfeeds.PandasData):

    params = (
        ('datetime', -1),
        ('high', 'high'),
        ('low', 'low'),
        ('close', 'close'),
    )

    # 既存のデータフレーム 'df' に対して、NaNを含む行を削除
    df = df.dropna()

    def __init__(self):
        super(PandasDataFeed, self).__init__()

class BollingerStrategy(btStrategy):
    params = {
        'time_period_to_close': 1,
    }

    def __init__(self):
        self.first_bar = True

        self.datetime = self.datas[0].datetime
        self.high = self.datas[0].high
        self.low = self.datas[0].low
        self.close = self.datas[0].close
        self.bar_executed = 0

    def next(self):
        
        if self.first_bar:
            self.first_bar = False
            return

        self.buy()
        
        if self.position:g
            self.sell()

    def log(self, txt, dt=None):
        """ Logging function for this strategy"""
        dt = dt or self.datas[0].datetime.datetime(0)
        print('%s, %s' % (dt.isoformat(), txt))

class SafeAnnualReturn(btanalyzers.AnnualReturn):
    def start(self):
        super().start()
        self._value_start = self.strategy.broker.getvalue()

    def stop(self):
        value_start = self._value_start
        value_end = self.strategy.broker.getvalue()

        if value_start != 0.0 and len(self.strategy.datetime.array) > 0:
            annualret = (value_end / value_start) - 1.0
            if len(self.rets) > 0:
                self.rets[self.strategy.datetime.datetime(-1)] = annualret
            else:
                self.rets[self.strategy.datetime.datetime(-1)] = annualret
        else:
            if len(self.strategy.datetime.array) > 0:
                self.rets[self.strategy.datetime.datetime(-1)] = 0.0
            else:
                self.rets[self.strategy.datetime.datetime(-1)] = 0.0

    def get_analysis(self):
        return self.rets
            
# バックテストの実行と評価
# Cerebroエンジンの初期化
cerebro = bt.Cerebro()

# データフィードの追加
data_feed = PandasDataFeed(dataname=df)
cerebro.adddata(data_feed)

# 戦略の追加
cerebro.addstrategy(BollingerStrategy)

# 分析機能の追加
cerebro.addanalyzer(btanalyzers.SharpeRatio, _name='sharpe_ratio')
cerebro.addanalyzer(btanalyzers.DrawDown, _name='drawdown')
cerebro.addanalyzer(SafeAnnualReturn, _name='annual_return')
cerebro.addanalyzer(btanalyzers.SharpeRatio, _name='mySharpeRatio')

# 初期資本の設定
cerebro.broker.setcash(100000.0)
cerebro.addsizer(bt.sizers.FixedSize, stake=1)

# バックテストの実行
results = cerebro.run()

# 分析結果の取得
sharpe_ratio = results[0].analyzers.sharpe_ratio.get_analysis()['sharperatio']
drawdown = results[0].analyzers.drawdown.get_analysis()
annual_return = results[0].analyzers.annual_return.get_analysis()

# 最終資産額と分析結果の表示
print('Final Portfolio Value:', cerebro.broker.getvalue())
print('Sharpe Ratio:', sharpe_ratio)
print('Max Drawdown:', drawdown['max']['drawdown'])
print('Annual Return:', annual_return)

#results変数を確認し、異常な値が含まれているかどうかをチェック
print("Sharpe Ratio Analysis:", results[0].analyzers.sharpe_ratio.get_analysis())
print("Drawdown Analysis:", results[0].analyzers.drawdown.get_analysis())
print("Annual Return Analysis:", results[0].analyzers.annual_return.get_analysis())

# プロットの設定
plt.style.use('seaborn-whitegrid')
matplotlib.rcParams.update({'font.size': 8})
fig, ax1 = plt.subplots(figsize=(12, 6))

# バックテストの結果をプロット
cerebro.plot(iplot=False, ax=ax1)

# プロットの保存
plt.savefig("backtest_results.png", dpi=300, bbox_inches='tight')

# 結果をファイルに保存
with open("backtest_results.txt", "w") as f:
    f.write("Final Portfolio Value: {}\n".format(cerebro.broker.getvalue()))
    f.write("Sharpe Ratio: {}\n".format(sharpe_ratio))
    f.write("Max Drawdown: {}\n".format(drawdown['max']['drawdown']))
    f.write("Annual Return: {}\n".format(annual_return))
    f.write("\n")
    f.write("Sharpe Ratio Analysis: {}\n".format(results[0].analyzers.sharpe_ratio.get_analysis()))
    f.write("Drawdown Analysis: {}\n".format(results[0].analyzers.drawdown.get_analysis()))
    f.write("Annual Return Analysis: {}\n".format(results[0].analyzers.annual_return.get_analysis()))

# バックテスト結果の詳細を表示
print("Strategy analysis:")
for k, v in results[0].analyzers.items():
    print("  {}: {}".format(k, v.get_analysis()))

print("Backtest completed successfully.")
```

### 試したこと

データに欠損値がないことは確認し、欠損値があれば行ごと削除するという前処理は実行しています。
df上のデータ、計算後のデータもprintで確認し問題はありませんでした。


### 補足情報（FW/ツールのバージョンなど）

windows11


backtrader（バックテスト）に、注文を反映させたい。

### 実現したいこと

pythonで関数により得られた戻り値をmatplotlibを用いてグラフに出力したい。

### 前提
y=x+2という方程式を関数の戻り値を用いてグラフに出力したい



### 発生している問題・エラーメッセージ

```
NameError                                 Traceback (most recent call last)
<ipython-input-10-9978d481420a> in <cell line: 10>()
      8     return y
      9 
---> 10 plt.plot(x,y)
     11 plt.show()

NameError: name 'y' is not defined
```

### 該当のソースコード

```Python
mport numpy as np
import matplotlib.pyplot as plt

x=np.arange(0,11,1)
a=1;b=2
def func(x,a,b):
    y=a*x+b
    return y

plt.plot(x,y)
plt.show()
```

### 試したこと

x,a,bをそれぞれ変数として定義すると描画はできた
### 補足情報（FW/ツールのバージョンなど）

ここにより詳細な情報を記載してください。


pythonにおける関数の戻り値の出力についてです

## テーマ、知りたいこと

以下のコードでどうして画面に表示されるかわかりません。

## 背景、状況

Python初心者で、あるサイトのコードを参照しながら、階層型クラスタリングを行っていました。
そして、そのデンドログラムを可視化する際に以下のコードが用いられていました。

```Python
import scipy.cluster.hierarchy as sch
import matplotlib.pyplot as plt

#クラスタリング軸設定(年収vsマンション費用)
X = df.iloc[:, [3, 4]].values

#樹形図作成用インスタンス
dendrogram = sch.dendrogram(sch.linkage(X, method = 'ward'))

#樹形図可視化
plt.title('Dendrogram')
plt.xlabel('Salary vs Apartment Cost')
plt.ylabel('Euclidean distances')
plt.show()
```

このコードを実行すると、デンドログラムが表示されましたが、疑問があります。

pltには、デンドログラムがを表示するコードはひとつも含まれていません。
私がコードを見る限りは、タイトルと軸ラベルを設定しただけです。
にもかかわらず、実際には、デンドログラムが表示され、そのタイトルと軸ラベルが表示されているのです。

## 質問

このplotの仕組みがわかりません。教えていただきたいです。
また、一般的にfig,ax = plt.subplots()として書き進めていくのであれば、どのように書き換えることができますか？



どうしてこのコードでグラフが可視化できる？

### 実現したいこと
for文で60個のグラフを別々の領域に描画したい

### 前提
for文で60個のヒストグラムを重ねずに描画したいのですが、実行するとグラフが潰れて表示されてしまいます。解決法を教えていただきたいです。
### 発生している問題・エラーメッセージ

```

```
![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2023-04-28/b86e5222-194b-4596-9916-bf4ee3ff0f90.png)
### 該当のソースコード

```ここに言語名を入力
fig, axes = plt.subplots(60,figsize=(8,8))
for i in range(60):
    df1=df[0+i*400:400+i*400]
    x=df1["radius"].values
    axes[i].hist(x,bins=40)
```

### 試したこと

ここに問題に対して試したことを記載してください。

### 補足情報（FW/ツールのバージョンなど）

ここにより詳細な情報を記載してください。


for文で書いた複数のグラフが潰れてしまう。

### 実現したいこと
matplotlibによるアニメーションの保存時間を短縮したい
### 前提

animationの保存に30分以上かかってしまいます。保存されたgifはイメージ通りで正しいと思われます。

### 発生している問題・エラーメッセージ

エラーメッセージ無し
保存時間が長すぎる

### 該当のソースコード

```python
#必要なライブラリのインポート
import random
import numpy as np
import matplotlib.pyplot as plt
import numpy.random as rand

#行数と列数の指定
m = 20
n = 20
#訓練データの数を指定 
n_x =4000

#ランダムなRGB値をもつn_xこの訓練データを生成。各要素は３つずつ。
train_data = np.random.randint(0, 255, (n_x, 3))

#ランダムなRGB値を持つSOMの初期状態をsomと定義。生成された整数値を浮動小数点に変換。
som = np.random.randint(0, 255, (m, n, 3)).astype(float)

#SOMを画像として表示する。浮動小数点の値をsom.astype(int)で整数に変換。軸オブジェクトを取得。x軸とy軸を非表示に設定。
plt.imshow(som.astype(int))
ax = plt.gca()
ax.axes.xaxis.set_visible(False)
ax.axes.yaxis.set_visible(False)
# SOM内のBMUを見つける。SOMと入力ベクトルx（ランダムに抽出された訓練データ）の間のユークリッド距離の二乗を計算し、最小値の座標を返す。
def find_BMU(SOM,x):
    distSq = (np.square(SOM - x)).sum(axis=2)
    return np.unravel_index(np.argmin(distSq, axis=None), distSq.shape)
    
# update_weightsは、与えられた1つのトレーニング例と、BMUの座標を含むモデルパラメータと共に、SOMのセルの重みを更新する
def update_weights(SOM, train_ex, learn_rate, radius_sq, 
                   BMU_coord, step=3):
    g, h = BMU_coord
    #半径が０に近いとき、BMUのみ変更する
    if radius_sq < 1e-3:
        SOM[g,h,:] += learn_rate * (train_ex - SOM[g,h,:])
        return SOM
    # BMUの小さい近傍全てのセルを更新する。dist_funcは距離感数で、ガウス関数に基づいており、BMUから離れるにつれて減衰する。学習率、距離感数、トレーニング例との差を乗算して、近傍セルの重みを更新する。

    for i in range(max(0, g-step), min(SOM.shape[0], g+step)):
        for j in range(max(0, h-step), min(SOM.shape[1], h+step)):
            dist_sq = np.square(i - g) + np.square(j - h)
            dist_func = np.exp(-dist_sq / 2 / radius_sq)
            SOM[i,j,:] += learn_rate * dist_func * (train_ex - SOM[i,j,:])   
    return SOM    


def train_SOM(SOM, train_data, learn_rate = .001, radius_sq = 1, 
             lr_decay = .001, radius_decay = .1, epochs = 100):    
#初期の学習率と半径の２乗を保持する（学習率と減衰を制御するため）  
    learn_rate_0=learn_rate
    radius_0 = radius_sq
#指定されたエポック数の回数だけトレーニングを繰り返す。
    for epoch in np.arange(0, epochs):
        #各エポックごとに、トレーニングデータセットをランダムにシャッフルする。
        rand.shuffle(train_data)      
        #SOMの重みを更新する
        for train_ex in train_data:
            g, h = find_BMU(SOM, train_ex)
            SOM = update_weights(SOM, train_ex, 
                                 learn_rate, radius_sq, (g,h))
        # 学習率と半径の更新（学習率は指数関数的に減衰し、エポックごとに小さくなる。同様に、半径も指数関数的に減衰し、トレーニングの進行に応じて小さくなる）
        learn_rate = learn_rate_0 * np.exp(-epoch * lr_decay)
        radius_sq = radius_0 * np.exp(-epoch * radius_decay)            
    return SOM

import matplotlib.animation as animation
from PIL import Image

#初期のSOMの状態を表示。somを整数型に変換し、x軸y軸を非表示にする。
fig, ax = plt.subplots(figsize=(3, 3))
ax.imshow(som.astype(int))
ax.axes.xaxis.set_visible(False)
ax.axes.yaxis.set_visible(False)


def update(frame):
    global som
    SOM = train_SOM(som, train_data)
    ax.imshow(SOM.astype(int))
    som = SOM
    return ax

ani = animation.FuncAnimation(fig, update, frames=1000, interval=.000001, blit=False)
# アニメーションをGIFファイルとして保存する
ani.save('SOM_training_animation.gif', writer='imagemagick', fps=10)
```

### 試したこと

学習率などパラメータの変更は試してみましたが、変化がありませんでした。

### 補足情報（FW/ツールのバージョンなど）

ここにより詳細な情報を記載してください。
