diff --git a/husky_mpc/CMakeLists.txt b/husky_mpc/CMakeLists.txt
new file mode 100644
index 0000000..d3ea737
--- /dev/null
+++ b/husky_mpc/CMakeLists.txt
@@ -0,0 +1,208 @@
+cmake_minimum_required(VERSION 2.8.3)
+project(husky_mpc)
+
+## Compile as C++11, supported in ROS Kinetic and newer
+# add_compile_options(-std=c++11)
+
+## Find catkin macros and libraries
+## if COMPONENTS list like find_package(catkin REQUIRED COMPONENTS xyz)
+## is used, also find other catkin packages
+find_package(catkin REQUIRED COMPONENTS
+ geometry_msgs
+ nav_msgs
+ roscpp
+ rospy
+ std_msgs
+)
+
+## System dependencies are found with CMake's conventions
+# find_package(Boost REQUIRED COMPONENTS system)
+
+
+## Uncomment this if the package has a setup.py. This macro ensures
+## modules and global scripts declared therein get installed
+## See http://ros.org/doc/api/catkin/html/user_guide/setup_dot_py.html
+# catkin_python_setup()
+
+################################################
+## Declare ROS messages, services and actions ##
+################################################
+
+## To declare and build messages, services or actions from within this
+## package, follow these steps:
+## * Let MSG_DEP_SET be the set of packages whose message types you use in
+## your messages/services/actions (e.g. std_msgs, actionlib_msgs, ...).
+## * In the file package.xml:
+## * add a build_depend tag for "message_generation"
+## * add a build_depend and a exec_depend tag for each package in MSG_DEP_SET
+## * If MSG_DEP_SET isn't empty the following dependency has been pulled in
+## but can be declared for certainty nonetheless:
+## * add a exec_depend tag for "message_runtime"
+## * In this file (CMakeLists.txt):
+## * add "message_generation" and every package in MSG_DEP_SET to
+## find_package(catkin REQUIRED COMPONENTS ...)
+## * add "message_runtime" and every package in MSG_DEP_SET to
+## catkin_package(CATKIN_DEPENDS ...)
+## * uncomment the add_*_files sections below as needed
+## and list every .msg/.srv/.action file to be processed
+## * uncomment the generate_messages entry below
+## * add every package in MSG_DEP_SET to generate_messages(DEPENDENCIES ...)
+
+## Generate messages in the 'msg' folder
+# add_message_files(
+# FILES
+# Message1.msg
+# Message2.msg
+# )
+
+## Generate services in the 'srv' folder
+# add_service_files(
+# FILES
+# Service1.srv
+# Service2.srv
+# )
+
+## Generate actions in the 'action' folder
+# add_action_files(
+# FILES
+# Action1.action
+# Action2.action
+# )
+
+## Generate added messages and services with any dependencies listed here
+# generate_messages(
+# DEPENDENCIES
+# geometry_msgs# navigation_msgs# std_msgs
+# )
+
+################################################
+## Declare ROS dynamic reconfigure parameters ##
+################################################
+
+## To declare and build dynamic reconfigure parameters within this
+## package, follow these steps:
+## * In the file package.xml:
+## * add a build_depend and a exec_depend tag for "dynamic_reconfigure"
+## * In this file (CMakeLists.txt):
+## * add "dynamic_reconfigure" to
+## find_package(catkin REQUIRED COMPONENTS ...)
+## * uncomment the "generate_dynamic_reconfigure_options" section below
+## and list every .cfg file to be processed
+
+## Generate dynamic reconfigure parameters in the 'cfg' folder
+# generate_dynamic_reconfigure_options(
+# cfg/DynReconf1.cfg
+# cfg/DynReconf2.cfg
+# )
+
+###################################
+## catkin specific configuration ##
+###################################
+## The catkin_package macro generates cmake config files for your package
+## Declare things to be passed to dependent projects
+## INCLUDE_DIRS: uncomment this if your package contains header files
+## LIBRARIES: libraries you create in this project that dependent projects also need
+## CATKIN_DEPENDS: catkin_packages dependent projects also need
+## DEPENDS: system dependencies of this project that dependent projects also need
+catkin_package(
+# INCLUDE_DIRS include
+# LIBRARIES husky_mpc
+# CATKIN_DEPENDS geometry_msgs navigation_msgs roscpp rospy std_msgs
+# DEPENDS system_lib
+)
+
+###########
+## Build ##
+###########
+
+## Specify additional locations of header files
+## Your package locations should be listed before other locations
+include_directories(
+# include
+ ${catkin_INCLUDE_DIRS}
+)
+
+## Declare a C++ library
+# add_library(${PROJECT_NAME}
+# src/${PROJECT_NAME}/husky_mpc.cpp
+# )
+
+## Add cmake target dependencies of the library
+## as an example, code may need to be generated before libraries
+## either from message generation or dynamic reconfigure
+# add_dependencies(${PROJECT_NAME} ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS})
+
+## Declare a C++ executable
+## With catkin_make all packages are built within a single CMake context
+## The recommended prefix ensures that target names across packages don't collide
+# add_executable(${PROJECT_NAME}_node src/husky_mpc_node.cpp)
+
+## Rename C++ executable without prefix
+## The above recommended prefix causes long target names, the following renames the
+## target back to the shorter version for ease of user use
+## e.g. "rosrun someones_pkg node" instead of "rosrun someones_pkg someones_pkg_node"
+# set_target_properties(${PROJECT_NAME}_node PROPERTIES OUTPUT_NAME node PREFIX "")
+
+## Add cmake target dependencies of the executable
+## same as for the library above
+# add_dependencies(${PROJECT_NAME}_node ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS})
+
+## Specify libraries to link a library or executable target against
+# target_link_libraries(${PROJECT_NAME}_node
+# ${catkin_LIBRARIES}
+# )
+
+#############
+## Install ##
+#############
+
+# all install targets should use catkin DESTINATION variables
+# See http://ros.org/doc/api/catkin/html/adv_user_guide/variables.html
+
+## Mark executable scripts (Python etc.) for installation
+## in contrast to setup.py, you can choose the destination
+# install(PROGRAMS
+# scripts/my_python_script
+# DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
+# )
+
+## Mark executables for installation
+## See http://docs.ros.org/melodic/api/catkin/html/howto/format1/building_executables.html
+# install(TARGETS ${PROJECT_NAME}_node
+# RUNTIME DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
+# )
+
+## Mark libraries for installation
+## See http://docs.ros.org/melodic/api/catkin/html/howto/format1/building_libraries.html
+# install(TARGETS ${PROJECT_NAME}
+# ARCHIVE DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION}
+# LIBRARY DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION}
+# RUNTIME DESTINATION ${CATKIN_GLOBAL_BIN_DESTINATION}
+# )
+
+## Mark cpp header files for installation
+# install(DIRECTORY include/${PROJECT_NAME}/
+# DESTINATION ${CATKIN_PACKAGE_INCLUDE_DESTINATION}
+# FILES_MATCHING PATTERN "*.h"
+# PATTERN ".svn" EXCLUDE
+# )
+
+## Mark other files for installation (e.g. launch and bag files, etc.)
+# install(FILES
+# # myfile1
+# # myfile2
+# DESTINATION ${CATKIN_PACKAGE_SHARE_DESTINATION}
+# )
+
+#############
+## Testing ##
+#############
+
+## Add gtest based cpp test target and link libraries
+# catkin_add_gtest(${PROJECT_NAME}-test test/test_husky_mpc.cpp)
+# if(TARGET ${PROJECT_NAME}-test)
+# target_link_libraries(${PROJECT_NAME}-test ${PROJECT_NAME})
+# endif()
+
+## Add folders to be run by python nosetests
+# catkin_add_nosetests(test)
diff --git a/husky_mpc/package.xml b/husky_mpc/package.xml
new file mode 100644
index 0000000..a4c6bc6
--- /dev/null
+++ b/husky_mpc/package.xml
@@ -0,0 +1,74 @@
+
+
+ husky_mpc
+ 0.0.0
+ The husky_mpc package
+
+
+
+
+ marcello
+
+
+
+
+
+ TODO
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ catkin
+ geometry_msgs
+ nav_msgs
+ roscpp
+ rospy
+ std_msgs
+ geometry_msgs
+ nav_msgs
+ roscpp
+ rospy
+ std_msgs
+ geometry_msgs
+ nav_msgs
+ roscpp
+ rospy
+ std_msgs
+
+
+
+
+
+
+
+
diff --git a/husky_mpc/scripts/cvxpy_mpc.py b/husky_mpc/scripts/cvxpy_mpc.py
new file mode 100755
index 0000000..666f7a9
--- /dev/null
+++ b/husky_mpc/scripts/cvxpy_mpc.py
@@ -0,0 +1,176 @@
+import numpy as np
+from scipy.integrate import odeint
+from scipy.interpolate import interp1d
+import cvxpy as cp
+
+def get_linear_model(x_bar,u_bar):
+ """
+ """
+
+ # Control problem statement.
+
+ N = 5 #number of state variables
+ M = 2 #number of control variables
+ T = 20 #Prediction Horizon
+ dt = 0.25 #discretization step
+
+ x = x_bar[0]
+ y = x_bar[1]
+ theta = x_bar[2]
+ psi = x_bar[3]
+ cte = x_bar[4]
+
+ v = u_bar[0]
+ w = u_bar[1]
+
+ A = np.zeros((N,N))
+ A[0,2]=-v*np.sin(theta)
+ A[1,2]=v*np.cos(theta)
+ A[4,3]=v*np.cos(-psi)
+ A_lin=np.eye(N)+dt*A
+
+ B = np.zeros((N,M))
+ B[0,0]=np.cos(theta)
+ B[1,0]=np.sin(theta)
+ B[2,1]=1
+ B[3,1]=-1
+ B[4,0]=np.sin(-psi)
+ B_lin=dt*B
+
+ f_xu=np.array([v*np.cos(theta),v*np.sin(theta),w,-w,v*np.sin(-psi)]).reshape(N,1)
+ C_lin = dt*(f_xu - np.dot(A,x_bar.reshape(N,1)) - np.dot(B,u_bar.reshape(M,1)))
+
+ return A_lin,B_lin,C_lin
+
+def calc_err(state,path):
+ """
+ Finds psi and cte w.r.t. the closest waypoint.
+
+ :param state: array_like, state of the vehicle [x_pos, y_pos, theta]
+ :param path: array_like, reference path ((x1, x2, ...), (y1, y2, ...), (th1 ,th2, ...)]
+ :returns: (float,float)
+ """
+
+ dx = state[0]-path[0,:]
+ dy = state[1]-path[1,:]
+ dist = np.sqrt(dx**2 + dy**2)
+ nn_idx = np.argmin(dist)
+
+ try:
+ v = [path[0,nn_idx+1] - path[0,nn_idx],
+ path[1,nn_idx+1] - path[1,nn_idx]]
+ v /= np.linalg.norm(v)
+
+ d = [path[0,nn_idx] - state[0],
+ path[1,nn_idx] - state[1]]
+
+ if np.dot(d,v) > 0:
+ target_idx = nn_idx
+ else:
+ target_idx = nn_idx+1
+
+ except IndexError as e:
+ target_idx = nn_idx
+
+ path_ref_vect = [np.cos(path[2,target_idx] + np.pi / 2),
+ np.sin(path[2,target_idx] + np.pi / 2)]
+
+ #heading error w.r.t path frame
+ psi = path[2,target_idx] - state[2]
+
+ # the cross-track error is given by the scalar projection of the car->wp vector onto the faxle versor
+ #cte = np.dot([dx[target_idx], dy[target_idx]],front_axle_vect)
+ cte = np.dot([dx[target_idx], dy[target_idx]],path_ref_vect)
+
+ return target_idx,psi,cte
+
+def optimize(starting_state,u_bar,track);
+ '''
+ :param starting_state:
+ :param u_bar:
+ :param track:
+ :returns:
+ '''
+
+ MAX_SPEED = 1.25
+ MIN_SPEED = 0.75
+ MAX_STEER_SPEED = 1.57/2
+
+ N = 5 #number of state variables
+ M = 2 #number of control variables
+ T = 20 #Prediction Horizon
+ dt = 0.25 #discretization step
+
+ #Starting Condition
+ x0 = np.zeros(N)
+ x0[0] = starting_state[0]
+ x0[1] = starting_state[1]
+ x0[2] = starting_state[2]
+ _,psi,cte = calc_err(x0,track)
+ x0[3]=psi
+ x0[4]=cte
+
+ # Prediction
+ x_bar=np.zeros((N,T+1))
+ x_bar[:,0]=x0
+
+ for t in range (1,T+1):
+ xt=x_bar[:,t-1].reshape(5,1)
+ ut=u_bar[:,t-1].reshape(2,1)
+
+ A,B,C=get_linear_model(xt,ut)
+
+ xt_plus_one = np.squeeze(np.dot(A,xt)+np.dot(B,ut)+C)
+
+ _,psi,cte = calc_err(xt_plus_one,track)
+ xt_plus_one[3]=psi
+ xt_plus_one[4]=cte
+
+ x_bar[:,t]= xt_plus_one
+
+ #CVXPY Linear MPC problem statement
+ cost = 0
+ constr = []
+ x = cp.Variable((N, T+1))
+ u = cp.Variable((M, T))
+
+ for t in range(T):
+
+ # Tracking
+ if t > 0:
+ idx,_,_ = calc_err(x_bar[:,t],track)
+ delta_x = track[:,idx]-x[0:3,t]
+ cost+= cp.quad_form(delta_x,10*np.eye(3))
+
+ # Tracking last time step
+ if t == T:
+ idx,_,_ = calc_err(x_bar[:,t],track)
+ delta_x = track[:,idx]-x[0:3,t]
+ cost+= cp.quad_form(delta_x,100*np.eye(3))
+
+ # Actuation rate of change
+ if t < (T - 1):
+ cost += cp.quad_form(u[:, t + 1] - u[:, t], 25*np.eye(M))
+
+ # Actuation effort
+ cost += cp.quad_form( u[:, t],1*np.eye(M))
+
+ # Constrains
+ A,B,C=get_linear_model(x_bar[:,t],u_bar[:,t])
+ constr += [x[:,t+1] == A*x[:,t] + B*u[:,t] + C.flatten()]
+
+ # sums problem objectives and concatenates constraints.
+ constr += [x[:,0] == x_sim[:,sim_time]] # starting condition
+ constr += [u[0, :] <= MAX_SPEED]
+ constr += [u[0, :] >= MIN_SPEED]
+ constr += [cp.abs(u[1, :]) <= MAX_STEER_SPEED]
+
+ # Solve
+ prob = cp.Problem(cp.Minimize(cost), constr)
+ solution = prob.solve(solver=cp.ECOS, verbose=False)
+
+ #retrieved optimized U and assign to u_bar to linearize in next step
+ u_bar=np.vstack((np.array(u.value[0, :]).flatten(),
+ (np.array(u.value[1, :]).flatten())))
+
+ return u_bar
\ No newline at end of file
diff --git a/husky_mpc/scripts/mpc_node.py b/husky_mpc/scripts/mpc_node.py
new file mode 100755
index 0000000..f60dedb
--- /dev/null
+++ b/husky_mpc/scripts/mpc_node.py
@@ -0,0 +1,84 @@
+#! /usr/bin/env python
+
+import rospy
+import numpy as np
+
+from nav_msgs.msg import Odometry
+
+from geometry_msgs.msg import Twist
+
+from utils import compute_path_from_wp
+from cvxpy_mpc import optimize
+
+# classes
+class Node():
+
+ def __init__(self):
+
+ rospy.init_node('mpc_node')
+
+ N = 5 #number of state variables
+ M = 2 #number of control variables
+ T = 20 #Prediction Horizon
+ dt = 0.25 #discretization step
+
+ # State for the robot mathematical model
+ self.state = None
+
+ # starting guess output
+ self.opt_u = np.zeros((M,T))
+ self.opt_u[0,:] = 1 #m/s
+ self.opt_u[1,:] = np.radians(0) #rad/s
+
+ # Interpolated Path to follow given waypoints
+ self.path = compute_path_from_wp([0,20,30,30],[0,0,10,20])
+
+ self._cmd_pub = rospy.Publisher(rospy.get_namespace() + 'husky_velocity_controller/cmd_vel', Twist, queue_size=10)
+ self._odom_sub = rospy.Subscriber(rospy.get_namespace() +'husky_velocity_controller/odom', Odometry, self._odom_cb, queue_size=1)
+
+ def run(self):
+ while 1:
+ if self.state is not None:
+
+ #optimization loop
+ self.opt_u = optimize(self.state,
+ self.opt_u,
+ self.path)
+
+ msg = Twist()
+ msg.linear.x=self.opt_u[0,1]
+ msg.angular.z=self.opt_u[0,1]
+
+ self._cmd_pub(msg)
+
+ def _odom_cb(self,odom):
+ '''
+ Updates state with latest odometry.
+
+ :param odom: nav_msgs.msg.Odometry
+ '''
+
+ state = np.zeros(3)
+
+ # Update current position
+ state[0] = odom.pose.pose.position.x
+ state[1] = odom.pose.pose.position.y
+
+ # Update current orientation
+ _, _, state[2] = euler_from_quaternion(
+ [odom.pose.pose.orientation.x,
+ odom.pose.pose.orientation.y,
+ odom.pose.pose.orientation.z,
+ odom.pose.pose.orientation.w])
+
+ self.state = state
+
+def main():
+ ros_node=Node()
+ try:
+ ros_node.run()
+ except rospy.exceptions.ROSException as e:
+ sys.exit(e)
+
+if __name__ == '__main__':
+ main()
\ No newline at end of file
diff --git a/husky_mpc/scripts/utils.py b/husky_mpc/scripts/utils.py
new file mode 100755
index 0000000..c978f42
--- /dev/null
+++ b/husky_mpc/scripts/utils.py
@@ -0,0 +1,33 @@
+import numpy as np
+from scipy.integrate import odeint
+from scipy.interpolate import interp1d
+import cvxpy as cp
+
+def compute_path_from_wp(start_xp, start_yp, step = 0.1):
+ """
+ Interpolation range is computed to assure one point every fixed distance step [m].
+
+ :param start_xp: array_like, list of starting x coordinates
+ :param start_yp: array_like, list of starting y coordinates
+ :param step: float, interpolation distance [m] between consecutive waypoints
+ :returns: array_like, of shape (3,N)
+ """
+
+ final_xp=[]
+ final_yp=[]
+ delta = step #[m]
+
+ for idx in range(len(start_xp)-1):
+ section_len = np.sum(np.sqrt(np.power(np.diff(start_xp[idx:idx+2]),2)+np.power(np.diff(start_yp[idx:idx+2]),2)))
+
+ interp_range = np.linspace(0,1,section_len/delta)
+
+ fx=interp1d(np.linspace(0,1,2),start_xp[idx:idx+2],kind=1)
+ fy=interp1d(np.linspace(0,1,2),start_yp[idx:idx+2],kind=1)
+
+ final_xp=np.append(final_xp,fx(interp_range))
+ final_yp=np.append(final_yp,fy(interp_range))
+
+ dx = np.append(0, np.diff(final_xp))
+ dy = np.append(0, np.diff(final_yp))
+ theta = np.arctan2(dy, dx)
diff --git a/husky_mpc/scripts/utils.pyc b/husky_mpc/scripts/utils.pyc
new file mode 100644
index 0000000..15af75a
Binary files /dev/null and b/husky_mpc/scripts/utils.pyc differ
diff --git a/.ipynb_checkpoints/MPC_cvxpy-checkpoint.ipynb b/notebooks/.ipynb_checkpoints/MPC_cvxpy-checkpoint.ipynb
similarity index 63%
rename from .ipynb_checkpoints/MPC_cvxpy-checkpoint.ipynb
rename to notebooks/.ipynb_checkpoints/MPC_cvxpy-checkpoint.ipynb
index 59c10ef..db4ff85 100644
--- a/.ipynb_checkpoints/MPC_cvxpy-checkpoint.ipynb
+++ b/notebooks/.ipynb_checkpoints/MPC_cvxpy-checkpoint.ipynb
@@ -291,8 +291,8 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "CPU times: user 4.51 ms, sys: 390 µs, total: 4.9 ms\n",
- "Wall time: 4.39 ms\n"
+ "CPU times: user 3.81 ms, sys: 0 ns, total: 3.81 ms\n",
+ "Wall time: 3.75 ms\n"
]
}
],
@@ -390,8 +390,8 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "CPU times: user 1.31 ms, sys: 5.59 ms, total: 6.91 ms\n",
- "Wall time: 2.05 ms\n"
+ "CPU times: user 404 µs, sys: 4.79 ms, total: 5.19 ms\n",
+ "Wall time: 1.54 ms\n"
]
}
],
@@ -819,8 +819,8 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "CPU times: user 329 ms, sys: 173 ms, total: 502 ms\n",
- "Wall time: 281 ms\n"
+ "CPU times: user 304 ms, sys: 195 ms, total: 499 ms\n",
+ "Wall time: 288 ms\n"
]
}
],
@@ -984,7 +984,7 @@
},
{
"cell_type": "code",
- "execution_count": 35,
+ "execution_count": 22,
"metadata": {},
"outputs": [
{
@@ -993,6 +993,13 @@
"text": [
"/home/marcello/.local/lib/python3.5/site-packages/ipykernel_launcher.py:18: RuntimeWarning: invalid value encountered in true_divide\n"
]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "CVXPY Optimization Time: Avrg: 0.2550s Max: 0.3976s Min: 0.2298s\n"
+ ]
}
],
"source": [
@@ -1001,6 +1008,7 @@
" [0,0,2.5,2.5,0,0,5,10])\n",
"\n",
"sim_duration =100 \n",
+ "opt_time=[]\n",
"\n",
"x_sim = np.zeros((N,sim_duration))\n",
"u_sim = np.zeros((M,sim_duration-1))\n",
@@ -1027,6 +1035,8 @@
"\n",
"for sim_time in range(sim_duration-1):\n",
" \n",
+ " iter_start=time.time()\n",
+ " \n",
" # Prediction\n",
" x_bar=np.zeros((N,T+1))\n",
" x_bar[:,0]=x_sim[:,sim_time]\n",
@@ -1057,10 +1067,16 @@
" idx,_,_ = calc_err(x_bar[:,t],track)\n",
" delta_x = track[:,idx]-x[0:3,t]\n",
" cost+= cp.quad_form(delta_x,10*np.eye(3))\n",
+ " \n",
+ " # Tracking last time step\n",
+ " if t == T:\n",
+ " idx,_,_ = calc_err(x_bar[:,t],track)\n",
+ " delta_x = track[:,idx]-x[0:3,t]\n",
+ " cost+= cp.quad_form(delta_x,100*np.eye(3))\n",
"\n",
" # Actuation rate of change\n",
" if t < (T - 1):\n",
- " cost += cp.quad_form(u[:, t + 1] - u[:, t], 5*np.eye(M))\n",
+ " cost += cp.quad_form(u[:, t + 1] - u[:, t], 25*np.eye(M))\n",
" \n",
" # Actuation effort\n",
" cost += cp.quad_form( u[:, t],1*np.eye(M))\n",
@@ -1085,22 +1101,29 @@
" \n",
" u_sim[:,sim_time] = u_bar[:,0]\n",
" \n",
+ " # Measure elpased time to get results from cvxpy\n",
+ " opt_time.append(time.time()-iter_start)\n",
+ " \n",
" # move simulation to t+1\n",
" tspan = [0,dt]\n",
" x_sim[:,sim_time+1] = odeint(kinematics_model,\n",
" x_sim[:,sim_time],\n",
" tspan,\n",
- " args=(u_bar[:,0],))[1]\n"
+ " args=(u_bar[:,0],))[1]\n",
+ " \n",
+ "print(\"CVXPY Optimization Time: Avrg: {:.4f}s Max: {:.4f}s Min: {:.4f}s\".format(np.mean(opt_time),\n",
+ " np.max(opt_time),\n",
+ " np.min(opt_time))) "
]
},
{
"cell_type": "code",
- "execution_count": 36,
+ "execution_count": 23,
"metadata": {},
"outputs": [
{
"data": {
- "image/png": "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\n",
+ "image/png": "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\n",
"text/plain": [
"