デフォルトのコード

import numpy as np

import matplotlib.pyplot as plt

import glob

import os

import warnings

lmbda = 2

w,h = 10,10

#パラメータ(ここでは二変数のみ)

beta0 = np.linspace(-w, w, 100)

beta1 = np.linspace(-h, h, 100)

B0, B1 = np.meshgrid(beta0, beta1)

def diamond(lmbda=1, n=100):

    "get points along diamond at distance lmbda from origin"

    points = []
    x = np.linspace(0, lmbda, num=n // 4)

    points.extend(list(zip(x, -x + lmbda)))

    x = np.linspace(0, lmbda, num=n // 4)

    points.extend(list(zip(x,  x - lmbda)))

    x = np.linspace(-lmbda, 0, num=n // 4)

    points.extend(list(zip(x, -x - lmbda)))

    x = np.linspace(-lmbda, 0, num=n // 4)

    points.extend(list(zip(x,  x + lmbda)))

    return np.array(points)

def circle(lmbda=1, n=100):

    # 極座標系

    points = []
    for angle in np.linspace(0,np.pi/2, num=n//4):

        x = np.cos(angle) * lmbda

        y = np.sin(angle) * lmbda

        points.append((x,y))

    for angle in np.linspace(np.pi/2,np.pi, num=n//4):

        x = np.cos(angle) * lmbda

        y = np.sin(angle) * lmbda

        points.append((x,y))

    for angle in np.linspace(np.pi, np.pi*3/2, num=n//4):

        x = np.cos(angle) * lmbda

        y = np.sin(angle) * lmbda

        points.append((x,y))

    for angle in np.linspace(np.pi*3/2, 2*np.pi,num=n//4):

        x = np.cos(angle) * lmbda

        y = np.sin(angle) * lmbda

        points.append((x,y))

    return np.array(points)

def loss(b0, b1,

         a = 1,

         b = 1,

         c = 0,     # a～c 軸の広がり

         cx = -10,  # x軸の中心からのずれ

         cy = 5):   # y軸の中心からのずれ

    return a * (b0 - cx) ** 2 + b * (b1 - cy) ** 2 + c * (b0 - cx) * (b1 - cy)

def select_parameters(lmbda, reg, force_symmetric_loss, force_one_nonpredictive):

    while True:

        a = np.random.random() * 10

        b = np.random.random() * 10

        c = np.random.random() * 4 - 1.5

        if force_symmetric_loss:

            b = a # 対称化

            c = 0

        elif force_one_nonpredictive:

            if np.random.random() > 0.5:

                a = np.random.random() * 15 - 5

                b = .1

            else:

                b = np.random.random() * 15 - 5

                a = .1

            c = 0

        x, y = 0, 0

        #L1正則化の時

        if reg=='L1':

            while np.abs(x) + np.abs(y) <= lmbda:

                x = np.random.random() * 2 * w - w

                y = np.random.random() * 2 * h - h

        #L2正則化の時

        else:

            while np.sqrt(x**2 + y**2) <= lmbda:

                x = np.random.random() * 2 * w - w

                y = np.random.random() * 2 * h - h

        #Lossの値(Z軸の値)

        Z = loss(B0, B1, a=a, b=b, c=c, cx=x, cy=y)

        loss_at_min = loss(x, y, a=a, b=b, c=c, cx=x, cy=y)

        if (Z >= loss_at_min).all(): #鞍点がない場合

            break

    return Z, a, b, c, x, y

def plot_loss(boundary, reg,

              boundary_color='#2D435D',

              boundary_dot_color='#E32CA6',

              force_symmetric_loss=False, force_one_nonpredictive=False,

              show_contours=True, contour_levels=50, show_loss_eqn=False,

              show_min_loss=True,idx=None,fig=None,ax=None,num_trials=None):

    Z, a, b, c, x, y = select_parameters(lmbda, reg,

                          force_symmetric_loss=force_symmetric_loss,

                          force_one_nonpredictive=force_one_nonpredictive)

    eqn = f"{a:.2f}(b0 - {x:.2f})^2 + {b:.2f}(b1 - {y:.2f})^2 + {c:.2f} b0 b1"

    n_col = 5

    if show_loss_eqn:

        ax[idx//n_col, idx%n_col].set_title(eqn, fontsize=10)

    ax[idx//n_col, idx%n_col].set_xlabel("x", fontsize=8, labelpad=0)

    ax[idx//n_col, idx%n_col].set_ylabel("y", fontsize=8, labelpad=-10)

    ax[idx//n_col, idx%n_col].set_xticks([-10,-5,0,5,10])

    ax[idx//n_col, idx%n_col].set_yticks([-10,-5,0,5,10])

    ax[idx//n_col, idx%n_col].set_xlabel(r"$w_1$", fontsize=8)

    ax[idx//n_col, idx%n_col].set_ylabel(r"$w_2$", fontsize=8)

    shape = ""

    if force_symmetric_loss:

        shape = "symmetric "

    elif force_one_nonpredictive:

        shape = "orthogonal "

    ax[idx//n_col, idx%n_col].set_title(f"{reg} constraint w/{shape}loss function", fontsize=8)

    if show_contours:

        ax[idx//n_col, idx%n_col].contour(B0, B1, Z, levels=contour_levels, linewidths=1.0, cmap='coolwarm')

    else:

        ax[idx//n_col, idx%n_col].contourf(B0, B1, Z, levels=contour_levels, cmap='coolwarm')

    # 軸の描画

    ax[idx//n_col, idx%n_col].plot([-w,+w],[0,0], '-', c='k', lw=.5)

    ax[idx//n_col, idx%n_col].plot([0, 0],[-h,h], '-', c='k', lw=.5)

    # 境界の描画

    if boundary is not None:

        ax[idx//n_col, idx%n_col].plot(boundary[:,0], boundary[:,1], '-', lw=1.5, c=boundary_color)

    # Lossの中心点の作図

    if show_min_loss:

        ax[idx//n_col, idx%n_col].scatter([x],[y], s=90, c='k')

    # 境界点の図示

    eqn = f"{a:.2f}(b0 - {x:.2f})^2 + {b:.2f}(b1 - {y:.2f})^2 + {c:.2f} (b0-{x:.2f}) (b1-{y:.2f})"

    if boundary is not None:

        losses = [loss(*edgeloc, a=a, b=b, c=c, cx=x, cy=y) for edgeloc in boundary]
        minloss_idx = np.argmin(losses)

        coeff = boundary[minloss_idx]
        ax[idx//n_col, idx%n_col].scatter([coeff[0]], [coeff[1]], s=90, c=boundary_dot_color)

        if force_symmetric_loss:

            if reg=='L2':

                ax[idx//n_col, idx%n_col].plot([x,0],[y,0], ':', c='k')

            else:

                ax[idx//n_col, idx%n_col].plot([x,coeff[0]],[y,coeff[1]], ':', c='k')

def show_example(reg, force_symmetric_loss=False, force_one_nonpredictive=False,num_trials=None):

    if num_trials <=5:

        fig,ax = plt.subplots(1,5,figsize=(10,2),squeeze=False)

    elif num_trials > 5 and num_trials<=10:

        fig,ax = plt.subplots(2,5,figsize=(10,4))

    elif num_trials > 10 and num_trials<=15:

        fig,ax = plt.subplots(3,5,figsize=(10,6))

        fig.subplots_adjust(hspace=0.6, wspace=0.4)

    if reg == 'L1':

        boundary = diamond(lmbda=lmbda, n=100)

    else:

        boundary = circle(lmbda=lmbda, n=100)

    for i in range(num_trials):

        plot_loss(boundary=boundary, reg=reg,

                  force_symmetric_loss=force_symmetric_loss,

                  force_one_nonpredictive=force_one_nonpredictive,

                  contour_levels=contour_levels,idx=i,fig=fig,ax=ax,num_trials=num_trials)

        shape_fname = ""

        if force_symmetric_loss:

            shape_fname = "symmetric-"

        elif force_one_nonpredictive:

            shape_fname = "orthogonal-"

        plt.tight_layout()

    #余分なaxesを消去

    if num_trials%5!=0:

        #余白数の計算

        k = 5*(1 + num_trials//5)-num_trials

        for i in range(k):

            fig.delaxes(ax[num_trials//5][-i-1])

    plt.show()

def just_contour():

    contour_levels = 400

    cx, cy = 4, .8

    beta0 = np.linspace(-w, w, 300)

    beta1 = np.linspace(-h, h, 300)

    B0, B1 = np.meshgrid(beta0, beta1)

    Z = loss(B0, B1, a=9, b=1, c=4.5, cx=cx, cy=cy)

    fig, ax = plt.subplots(1, 1, figsize=(8, 8))

    ax.set_xlim(-2,8)

    ax.set_ylim(-2,8)

    ax.set_xticks([])

    ax.set_yticks([])

    # ax.set_xlabel(r"$eta_1$", fontsize=12)

    # ax.set_ylabel(r"$eta_2$", fontsize=12)

    ax.contour(B0, B1, Z, levels=contour_levels, linewidths=.8, cmap='coolwarm', vmax=380)

    # Draw axes

    ax.plot([-w, +w], [0, 0], '-', c='k', lw=.5)

    ax.plot([0, 0], [-h, h], '-', c='k', lw=.5)

    lmbda = 2.58

    boundary_color = '#2D435D'

    boundary = diamond(lmbda=lmbda, n=200)

    ax.plot(boundary[:, 0], boundary[:, 1], '-', lw=.5, c=boundary_color)

    boundary = circle(lmbda=lmbda, n=200)

    ax.plot(boundary[:, 0], boundary[:, 1], '-', lw=.5, c=boundary_color)

    # Draw center of loss func

    ax.scatter([cx], [cy], s=20, c='k')

    plt.tight_layout()

    plt.show()

## main script ##

####以下の値で表示内容を切り替えてください.####

#n_trialsは15以下の数字を入力してください

n_trials = 12

contour_levels=50

mode = "L1"

s = 0

##############################################

np.random.seed(s)

show_example(reg=mode,num_trials=n_trials)

デフォルトのコード

import numpy as np

import matplotlib.pyplot as plt

import glob

import os

import warnings

lmbda = 2

w,h = 10,10

#パラメータ(ここでは二変数のみ)

beta0 = np.linspace(-w, w, 100)

beta1 = np.linspace(-h, h, 100)

B0, B1 = np.meshgrid(beta0, beta1)

def diamond(lmbda=1, n=100):

    "get points along diamond at distance lmbda from origin"

    points = []
    x = np.linspace(0, lmbda, num=n // 4)

    points.extend(list(zip(x, -x + lmbda)))

    x = np.linspace(0, lmbda, num=n // 4)

    points.extend(list(zip(x,  x - lmbda)))

    x = np.linspace(-lmbda, 0, num=n // 4)

    points.extend(list(zip(x, -x - lmbda)))

    x = np.linspace(-lmbda, 0, num=n // 4)

    points.extend(list(zip(x,  x + lmbda)))

    return np.array(points)

def circle(lmbda=1, n=100):

    # 極座標系

    points = []
    for angle in np.linspace(0,np.pi/2, num=n//4):

        x = np.cos(angle) * lmbda

        y = np.sin(angle) * lmbda

        points.append((x,y))

    for angle in np.linspace(np.pi/2,np.pi, num=n//4):

        x = np.cos(angle) * lmbda

        y = np.sin(angle) * lmbda

        points.append((x,y))

    for angle in np.linspace(np.pi, np.pi*3/2, num=n//4):

        x = np.cos(angle) * lmbda

        y = np.sin(angle) * lmbda

        points.append((x,y))

    for angle in np.linspace(np.pi*3/2, 2*np.pi,num=n//4):

        x = np.cos(angle) * lmbda

        y = np.sin(angle) * lmbda

        points.append((x,y))

    return np.array(points)

def loss(b0, b1,

         a = 1,

         b = 1,

         c = 0,     # a～c 軸の広がり

         cx = -10,  # x軸の中心からのずれ

         cy = 5):   # y軸の中心からのずれ

    return a * (b0 - cx) ** 2 + b * (b1 - cy) ** 2 + c * (b0 - cx) * (b1 - cy)

def select_parameters(lmbda, reg, force_symmetric_loss, force_one_nonpredictive):

    while True:

        a = np.random.random() * 10

        b = np.random.random() * 10

        c = np.random.random() * 4 - 1.5

        if force_symmetric_loss:

            b = a # 対称化

            c = 0

        elif force_one_nonpredictive:

            if np.random.random() > 0.5:

                a = np.random.random() * 15 - 5

                b = .1

            else:

                b = np.random.random() * 15 - 5

                a = .1

            c = 0

        x, y = 0, 0

        #L1正則化の時

        if reg=='L1':

            while np.abs(x) + np.abs(y) <= lmbda:

                x = np.random.random() * 2 * w - w

                y = np.random.random() * 2 * h - h

        #L2正則化の時

        else:

            while np.sqrt(x**2 + y**2) <= lmbda:

                x = np.random.random() * 2 * w - w

                y = np.random.random() * 2 * h - h

        #Lossの値(Z軸の値)

        Z = loss(B0, B1, a=a, b=b, c=c, cx=x, cy=y)

        loss_at_min = loss(x, y, a=a, b=b, c=c, cx=x, cy=y)

        if (Z >= loss_at_min).all(): #鞍点がない場合

            break

    return Z, a, b, c, x, y

def plot_loss(boundary, reg,

              boundary_color='#2D435D',

              boundary_dot_color='#E32CA6',

              force_symmetric_loss=False, force_one_nonpredictive=False,

              show_contours=True, contour_levels=50, show_loss_eqn=False,

              show_min_loss=True,idx=None,fig=None,ax=None,num_trials=None):

    Z, a, b, c, x, y = select_parameters(lmbda, reg,

                          force_symmetric_loss=force_symmetric_loss,

                          force_one_nonpredictive=force_one_nonpredictive)

    eqn = f"{a:.2f}(b0 - {x:.2f})^2 + {b:.2f}(b1 - {y:.2f})^2 + {c:.2f} b0 b1"

    n_col = 5

    if show_loss_eqn:

        ax[idx//n_col, idx%n_col].set_title(eqn, fontsize=10)

    ax[idx//n_col, idx%n_col].set_xlabel("x", fontsize=8, labelpad=0)

    ax[idx//n_col, idx%n_col].set_ylabel("y", fontsize=8, labelpad=-10)

    ax[idx//n_col, idx%n_col].set_xticks([-10,-5,0,5,10])

    ax[idx//n_col, idx%n_col].set_yticks([-10,-5,0,5,10])

    ax[idx//n_col, idx%n_col].set_xlabel(r"$w_1$", fontsize=8)

    ax[idx//n_col, idx%n_col].set_ylabel(r"$w_2$", fontsize=8)

    shape = ""

    if force_symmetric_loss:

        shape = "symmetric "

    elif force_one_nonpredictive:

        shape = "orthogonal "

    ax[idx//n_col, idx%n_col].set_title(f"{reg} constraint w/{shape}loss function", fontsize=8)

    if show_contours:

        ax[idx//n_col, idx%n_col].contour(B0, B1, Z, levels=contour_levels, linewidths=1.0, cmap='coolwarm')

    else:

        ax[idx//n_col, idx%n_col].contourf(B0, B1, Z, levels=contour_levels, cmap='coolwarm')

    # 軸の描画

    ax[idx//n_col, idx%n_col].plot([-w,+w],[0,0], '-', c='k', lw=.5)

    ax[idx//n_col, idx%n_col].plot([0, 0],[-h,h], '-', c='k', lw=.5)

    # 境界の描画

    if boundary is not None:

        ax[idx//n_col, idx%n_col].plot(boundary[:,0], boundary[:,1], '-', lw=1.5, c=boundary_color)

    # Lossの中心点の作図

    if show_min_loss:

        ax[idx//n_col, idx%n_col].scatter([x],[y], s=90, c='k')

    # 境界点の図示

    eqn = f"{a:.2f}(b0 - {x:.2f})^2 + {b:.2f}(b1 - {y:.2f})^2 + {c:.2f} (b0-{x:.2f}) (b1-{y:.2f})"

    if boundary is not None:

        losses = [loss(*edgeloc, a=a, b=b, c=c, cx=x, cy=y) for edgeloc in boundary]
        minloss_idx = np.argmin(losses)

        coeff = boundary[minloss_idx]
        ax[idx//n_col, idx%n_col].scatter([coeff[0]], [coeff[1]], s=90, c=boundary_dot_color)

        if force_symmetric_loss:

            if reg=='L2':

                ax[idx//n_col, idx%n_col].plot([x,0],[y,0], ':', c='k')

            else:

                ax[idx//n_col, idx%n_col].plot([x,coeff[0]],[y,coeff[1]], ':', c='k')

def show_example(reg, force_symmetric_loss=False, force_one_nonpredictive=False,num_trials=None):

    if num_trials <=5:

        fig,ax = plt.subplots(1,5,figsize=(10,2),squeeze=False)

    elif num_trials > 5 and num_trials<=10:

        fig,ax = plt.subplots(2,5,figsize=(10,4))

    elif num_trials > 10 and num_trials<=15:

        fig,ax = plt.subplots(3,5,figsize=(10,6))

        fig.subplots_adjust(hspace=0.6, wspace=0.4)

    if reg == 'L1':

        boundary = diamond(lmbda=lmbda, n=100)

    else:

        boundary = circle(lmbda=lmbda, n=100)

    for i in range(num_trials):

        plot_loss(boundary=boundary, reg=reg,

                  force_symmetric_loss=force_symmetric_loss,

                  force_one_nonpredictive=force_one_nonpredictive,

                  contour_levels=contour_levels,idx=i,fig=fig,ax=ax,num_trials=num_trials)

        shape_fname = ""

        if force_symmetric_loss:

            shape_fname = "symmetric-"

        elif force_one_nonpredictive:

            shape_fname = "orthogonal-"

        plt.tight_layout()

    #余分なaxesを消去

    if num_trials%5!=0:

        #余白数の計算

        k = 5*(1 + num_trials//5)-num_trials

        for i in range(k):

            fig.delaxes(ax[num_trials//5][-i-1])

    plt.show()

def just_contour():

    contour_levels = 400

    cx, cy = 4, .8

    beta0 = np.linspace(-w, w, 300)

    beta1 = np.linspace(-h, h, 300)

    B0, B1 = np.meshgrid(beta0, beta1)

    Z = loss(B0, B1, a=9, b=1, c=4.5, cx=cx, cy=cy)

    fig, ax = plt.subplots(1, 1, figsize=(8, 8))

    ax.set_xlim(-2,8)

    ax.set_ylim(-2,8)

    ax.set_xticks([])

    ax.set_yticks([])

    # ax.set_xlabel(r"$eta_1$", fontsize=12)

    # ax.set_ylabel(r"$eta_2$", fontsize=12)

    ax.contour(B0, B1, Z, levels=contour_levels, linewidths=.8, cmap='coolwarm', vmax=380)

    # Draw axes

    ax.plot([-w, +w], [0, 0], '-', c='k', lw=.5)

    ax.plot([0, 0], [-h, h], '-', c='k', lw=.5)

    lmbda = 2.58

    boundary_color = '#2D435D'

    boundary = diamond(lmbda=lmbda, n=200)

    ax.plot(boundary[:, 0], boundary[:, 1], '-', lw=.5, c=boundary_color)

    boundary = circle(lmbda=lmbda, n=200)

    ax.plot(boundary[:, 0], boundary[:, 1], '-', lw=.5, c=boundary_color)

    # Draw center of loss func

    ax.scatter([cx], [cy], s=20, c='k')

    plt.tight_layout()

    plt.show()

## main script ##

####以下の値で表示内容を切り替えてください.####

#n_trialsは15以下の数字を入力してください

n_trials = 12

contour_levels=50

mode = "L1"

s = 0

##############################################

np.random.seed(s)

show_example(reg=mode,num_trials=n_trials)

デフォルトのコード

# L2正則化 ラムダの値の変化による最小解の変化

# https://github.com/parrt/website-explained.ai/blob/master/regularization/code/l2loss_with_penalty.py

import numpy as np

from matplotlib import pyplot as plt

from matplotlib import animation

from mpl_toolkits.mplot3d import Axes3D

from matplotlib import cm

from matplotlib.patches import Circle

import mpl_toolkits.mplot3d.art3d as art3d

import glob

import os

from PIL import Image as PIL_Image
def diamond(lmbda=1, n=100):

    "get points along diamond at distance lmbda from origin"

    points = []
    x = np.linspace(0, lmbda, num=n // 4)

    points.extend(list(zip(x, -x + lmbda)))

    x = np.linspace(0, lmbda, num=n // 4)

    points.extend(list(zip(x,  x - lmbda)))

    x = np.linspace(-lmbda, 0, num=n // 4)

    points.extend(list(zip(x, -x - lmbda)))

    x = np.linspace(-lmbda, 0, num=n // 4)

    points.extend(list(zip(x,  x + lmbda)))

    return np.array(points)
def circle(lmbda=1, n=100):

    # 極座標系

    points = []
    for angle in np.linspace(0,np.pi/2, num=n//4):

        x = np.cos(angle) * lmbda

        y = np.sin(angle) * lmbda

        points.append((x,y))

    for angle in np.linspace(np.pi/2,np.pi, num=n//4):

        x = np.cos(angle) * lmbda

        y = np.sin(angle) * lmbda

        points.append((x,y))

    for angle in np.linspace(np.pi, np.pi*3/2, num=n//4):

        x = np.cos(angle) * lmbda

        y = np.sin(angle) * lmbda

        points.append((x,y))

    for angle in np.linspace(np.pi*3/2, 2*np.pi,num=n//4):

        x = np.cos(angle) * lmbda

        y = np.sin(angle) * lmbda

        points.append((x,y))

    return np.array(points)
def loss(b0, b1,

         a = 1,

         b = 1,

         c = 0,     # 軸の広がり

         cx = -10,  # x軸からのずれ

         cy = 5,    # y軸からのずれ

         lmbda=1.0,

         yintercept=100):

    eqn = f"{a:.2f}(b0 - {cx:.2f})^2 + {b:.2f}(b1 - {cy:.2f})^2 + {c:.2f} (b0-{cx:.2f}) (b1-{cy:.2f}) + {yintercept}"

    return lmbda * (a * (b0 - cx) ** 2 + b * (b1 - cy) ** 2) + c * (b0 - cx) * (b1 - cy) + yintercept
def loss_l1(b0,b1,a=1,b=1,c=0,cx=-10,cy=5,lmbda=1.0,yintercept=100):

    return lmbda*(a*np.abs(b0-cx) + b*np.abs(b1-cy))
#### Main Script ####

####stepsizeを変えると、表示するグラフの個数が変わります.

#### modeを'L1'にするとL1正則化、modeを'L2'にするとL2正則化になります.

mode = 'L1'

last_lmbda = 10

stepsize = 1.0

lmbdas = list(np.arange(1, last_lmbda, step=stepsize))

# lmbdas = [0]*3 + lmbdas + [last_lmbda]*3
#figの作成(この上にplotを複数描画していく)

fig = plt.figure(figsize=(10,10))

plt.subplots_adjust(wspace=0.4, hspace=2.0)

for i,lmbda in enumerate(lmbdas):

    ax = fig.add_subplot(3,3,i+1, projection='3d')

    ax.set_xlabel("$w_1$", labelpad=0)

    ax.set_ylabel("$w_2$", labelpad=0)

    ax.set_title(mode + "Regularization",fontsize=10)

    ax.tick_params(axis='x', pad=0)

    ax.tick_params(axis='y', pad=0)

    ax.set_zlim(0, 1400)
    cx = 15

    cy = -15
    ax.plot([cx], [cy], marker='x', markersize=10, color='black')

    ax.text(-20,20,800, f"$\lambda={lmbda:.1f}$", fontsize=10)
    beta0 = np.linspace(-30, 30, 300)

    beta1 = np.linspace(-30, 30, 300)

    #重みの値

    B0, B1 = np.meshgrid(beta0, beta1)
    if mode=='L2':

        #正則化項

        Z1 = loss(B0, B1, a=1, b=1, c=0, cx=0, cy=0, lmbda=lmbda, yintercept=0)

        #正則化前のLoss

        Z2 = loss(B0, B1, a=5, b=5, c=0, cx=cx, cy=cy, yintercept=0)

        #正則化後のLoss

        Z = Z1 + Z2
    elif mode=='L1':

        #正則化項

        Z1 = loss_l1(B0,B1,a=5,b=5,cx=0,cy=0,lmbda=lmbda)

        #正則化前のLoss

        Z2 = loss(B0, B1, a=5, b=5, c=0, cx=cx, cy=cy, yintercept=0)

        #正則化後のLoss

        Z = Z1 + Z2
    origin = Circle(xy=(0, 0), radius=1, color='k')

    ax.add_patch(origin)

    art3d.pathpatch_2d_to_3d(origin, z=0, zdir="z")
    scale = 1.5

    vmax = 8000

    contr = ax.contour(B0, B1, Z, levels=50, linewidths=.5,

                       cmap='coolwarm',

                       zdir='z', offset=0, vmax=vmax)
    #surface plot

    j = lmbda*scale

    b0 = (j, 20-j)

    beta0 = np.linspace(-j, 25-j, 300)

    beta1 = np.linspace(-25+j, j, 300)

    B0, B1 = np.meshgrid(beta0, beta1)
    if mode=='L1':

        Z1 = loss_l1(B0,B1,a=5,b=5,cx=0,cy=0,lmbda=lmbda)

        Z2 = loss(B0, B1, a=5, b=5, c=0, cx=cx, cy=cy, yintercept=0)

        Z = Z1 + Z2
    elif mode=='L2':

        Z1 = loss(B0, B1, a=1, b=1, c=0, cx=0, cy=0, lmbda=lmbda, yintercept=0)

        Z2 = loss(B0, B1, a=5, b=5, c=0, cx=cx, cy=cy, yintercept=0)

        Z = Z1 + Z2   
    vmax = 2700

    ax.plot_surface(B0, B1, Z, alpha=1.0, cmap='coolwarm', vmax=vmax)
    #正則化項の平面可視化

    if mode=="L1":

        boundary = diamond(lmbda=lmbda)

        ax.plot(boundary[:, 0], boundary[:, 1], '-', lw=.5, c="red")
    elif mode=="L2":

        boundary = circle(lmbda=lmbda)

        ax.plot(boundary[:, 0], boundary[:, 1], '-', lw=.5, c="red")
    ax.view_init(elev=38, azim=-134)
    plt.tight_layout()
plt.subplots_adjust(hspace=0.4)

plt.show()

デフォルトのコード

import plotly.graph_objects as go

import numpy as np

#L1正則化とL2正則化の表示切り替えが可能なPlotlyグラフの表示

def plot_regularization(mode):

    #表示するデータの作成

    #今回は変数が2つの二次元モデルと仮定し、重みw1 w2に対しての損失関数の値を3次元プロットする

    xx = np.linspace(-20, 20, 100)

    yy = np.linspace(-20, 20, 100)

    xs,ys = np.meshgrid(xx,yy)

    z1 = 10*(xs + 12)**2 + (10/4)*(ys + 12)**2 + 100# Lossの例
    #modeによって切り替えを行う

    if mode=="L1":

        z2 = 100*(np.abs(xs) + np.abs(ys)) #L1 正則化項
    else:

        z2 = 10*(xs**2 + ys**2) #L2 正則化項
    z3 = z1+z2
    # 表示

    sur1 = go.Surface(

        #特定の範囲に等高線を描く

        contours = {

        "z": {"show": True, "start": 0, "end": 60000, "size": 500,"project":{"z":True} ,"color":"blue"}

        },

        showscale=True,

        x = xs,

        y = ys,

        z = z1,

        name="Loss",

        showlegend=True,

        type='surface',

        cauto=False,

        reversescale=False, colorbar=go.ColorBar(x=-0.84)

    )
    sur2 = go.Surface(

        contours= {

        "z":{"show":True,"start":0, "end":60000, "size":500, "project":{"z":True},"color":"red"}

        },

        showscale=True,

        x = xs,

        y = ys,

        z = z2,

        name=mode,

        showlegend=True,

        type="surface",

        cauto=False,

        reversescale=False, colorbar=go.ColorBar(x=-0.84)

    )
    sur3 = go.Surface(

        contours= {

        "z":{"show":True,"start":0, "end":60000, "size":500,"project":{"z":True}, "color":"black"}

        },

        showscale=True,

        x = xs,

        y = ys,

        z = z3,

        name="Loss+" + mode,

        showlegend=True,

        type="surface",

        cauto=False,

        reversescale=False, colorbar=go.ColorBar(x=-0.84)

    )
    fig = go.Figure()
    fig.add_trace(go.Surface(sur1))

    fig.add_trace(go.Surface(sur2))

    fig.add_trace(go.Surface(sur3))
    #最初に表示する視点や大きさを決める

    fig.update_layout(

            scene = {

                "xaxis": {"nticks": 20,"title":"w1"},

                "yaxis":{"title":"w2"},

                "zaxis": {"nticks": 4,"title":"Loss"},

                'camera_eye': {"x": 1, "y": -1.5, "z": 1},

                "aspectratio": {"x": 1, "y": 1, "z": 1}

            },

            width=700,

            height=500)
    print(fig.to_html())
###########################

#main script

#modeで切り替えを行ってください

mode = "L1"

###########################

plot_regularization(mode)