code: def draw_scatters_hv(
      dft,
      nums,
      chart_format,
      problem_type,
      dep=None,
      classes=None,
      lowess=False,
      mk_dir="AutoViz_Plots",
      verbose=0,
  ):
      ensure_hvplot_imported()
      ######## SCATTER PLOTS ARE USEFUL FOR COMPARING NUMERIC VARIABLES
      ##### we are going to modify dfin and classes, so we are making copies to make changes
      dft = copy.deepcopy(dft)
      image_count = 0
      imgdata_list = list()
      classes = copy.deepcopy(classes)
      N = len(nums)
      cols = 2
      width_size = 600
      height_size = 400
      jitter = 0.05
      alpha = 0.5
      bubble_size = 10
      colortext = "brycgkbyrcmgkbyrcmgkbyrcmgkbyr"
      colors = cycle("brycgkbyrcmgkbyrcmgkbyrcmgkbyr")
      cmap_list = [
          "rainbow",
          "viridis",
          "plasma",
          "inferno",
          "magma",
          "cividis",
      ]
      plot_name = "scatterplots"
      #####################################################
      if problem_type == "Regression":
          ####### This is a Regression Problem #### You need to plot a Scatter plot ####
          ####### First, Plot each Continuous variable against the Target Variable ###
          ######   This is a Very Simple Way to build an Scatter Chart with One Variable as a Select Variable #######
          alpha = 0.5
  
          def load_symbol(symbol, **kwargs):
              color = next(colors)
              return (
                  hv.Scatter((dft[symbol].values, dft[dep].values))
                  .opts(framewise=True)
                  .opts(
                      size=bubble_size,
                      color=color,
                      alpha=alpha,
                      height=height_size,
                      width=width_size,
                  )
                  .opts(xlabel="%s" % symbol)
                  .opts(ylabel="%s" % dep)
                  .opts(
                      title="Scatter Plot of %s against %s variable"
                      % (symbol, dep)
                  )
              )
  
          ### This is where you create the dynamic map and pass it the variable to load the chart!
          dmap = (
              hv.DynamicMap(load_symbol, kdims="Select_Variable")
              .redim.values(Select_Variable=nums)
              .opts(framewise=True)
          )
          ###########  This is where you put the Panel Together ############
          hv_panel = pn.panel(dmap)
          widgets = hv_panel[0]
          hv_all = pn.Column(pn.Row(*widgets))
          if verbose == 2:
              imgdata_list = append_panels(
                  hv_panel, imgdata_list, chart_format
              )
              image_count += 1
      else:
          ##################################################################################################################
          ####### This is a Classification Problem #### You need to plot a Scatter plot ####
          #######   This widget based code works well except it does not add jitter. But it changes y-axis so that's good!
          ##################################################################################################################
          x = pn.widgets.Select(name="x", options=[dep])
          y = pn.widgets.Select(name="y", options=nums)
  
          @pn.depends(x.param.value, y.param.value)
          def create_figure(x, y):
              opts = dict(
                  cmap=cmap_list[0],
                  width=width_size,
                  height=height_size,
                  line_color="black",
              )
              opts["color"] = next(colors)
              opts["size"] = bubble_size
              opts["alpha"] = alpha
              opts["tools"] = ["hover"]
              opts["toolbar"] = "above"
              opts["colorbar"] = True
              opts[
                  "title"
              ] = "Scatter Plot of each numeric variable against target variable"
              return hv.Scatter(
                  dft,
                  [x, y],
                  label="%s vs %s" % (x.title(), y.title()),
              ).opts(**opts)
  
          widgets = pn.WidgetBox(x, y)
  
          hv_all = pn.Row(widgets, create_figure).servable(
              "Cross-selector"
          )
          #############  This is the old way of doing it - but it wasn't pretty ################
          # target_vars = dft[dep].unique()
          # x = pn.widgets.Select(name='x', options=nums)
          y = pn.widgets.Select(name="y", options=nums)
          kind = pn.widgets.Select(
              name="kind", value="scatter", options=["scatter"]
          )
          #######  This is where you call the widget and pass it the hv_plotto draw a Chart #######
          # hv_plot = dft.hvplot(x=dep, y=y, kind=kind, height=height_size, width=width_size, size=bubble_size,color = next(colors),
          #                title='Scatter Plot of each independent numeric variable against target variable')
          # hv_panel = pn.panel(hv_plot)
          # hv_all = pn.Row(pn.WidgetBox(y), hv_plot)
          ##
          ##################################################################################################################
          #############   This works well except that the y-axis does not change when you switch y-variable ################
          ##################################################################################################################
          # target_vars = dft[dep].unique().tolist()
          # color_list = list(colortext[:len(target_vars)])
          # def select_widget(Select_numeric_variable):
          #    """
          #    This program must take in a variable passed from the widget and turn it into a chart.
          #    The input is known as select_variable and it is the variable you must use to get the data and build a chart.
          #    The output must return a HoloViews Chart.
          #    """
          #    hv_string = ''
          #    target_list = np.unique(dfin[dep].values)
          #    lowerbound = dfin[Select_numeric_variable].min()
          #    upperbound = dfin[Select_numeric_variable].max()
          #    for each_t in target_list:
          #        if not isinstance(each_t, str):
          #            each_ts = str(each_t)
          #        else:
          #            each_ts = copy.deepcopy(each_t)
          #        next_color = next(colors)
          #        #add_string = "hv.Scatter((dfin[dfin['"+dep+"']=="+each_ts+"]['"+dep+"'].values,dfin[dfin['"+dep+"']=="+each_ts+"]['"+Select_numeric_variable+"'].values)).opts(color='"+next_color+"',jitter=eval('"+str(jitter)+"'),alpha=eval('"+str(alpha)+"'),size=eval('"+str(bubble_size)+"'),height=eval('"+str(height_size)+"'),width=eval('"+str(width_size)+"'))"
          #        add_string = "hv.Scatter((dfin[dfin['"+dep+"']=="+each_ts+"]['"+dep+"'].values,dfin[dfin['"+dep+"']=="+each_ts+"]['"+Select_numeric_variable+"'].values)).opts(color='"+next_color+"',jitter=eval('"+str(jitter)+"'),alpha=eval('"+str(alpha)+"'),ylim=(eval('"+str(lowerbound)+"'),eval('"+str(upperbound)+"')),height=eval('"+str(height_size)+"'),width=eval('"+str(width_size)+"'))"
          #        hv_string += add_string + " * "
          #    return eval(hv_string[:-2]).opts(
          #            legend_position='top_left',title='Scatter Plot of each Numeric Variable against Target variable')
          #######  This is where you call the widget and pass it the select_variable to draw a Chart #######
          #########   This is for bokeh server only ##############
          # dmap = hv.DynamicMap(select_widget,  kdims=['Select_numeric_variable']).redim.values(Select_numeric_variable=nums).opts(framewise=True)
          ###########  This is where you put the Panel Together ############
          # hv_panel = pn.panel(dmap)
          # widgets = hv_panel[0]
          # hv_all = pn.Column(pn.Row(*widgets))
          ###########  E N D    O F     Y- A X I S    C O D E    ############
          if verbose == 2:
              imgdata_list = append_panels(
                  hv_panel, imgdata_list, chart_format
              )
              image_count += 1
      ####### End of Scatter Plots ######
      if chart_format in ["server", "bokeh_server", "bokeh-server"]:
          # server = pn.serve(hv_all, start=True, show=True)
          print("%s can be found in URL below:" % plot_name)
          hv_all.show()
      elif chart_format == "html":
          save_html_data(hv_all, chart_format, plot_name, mk_dir)
      else:
          display(
              hv_all
          )  ### This will display it in a Jupyter Notebook. If you want it on a server, you use drawobj.show()
      return hv_all
  
imports: import numpy
  import pandas
  from autoviz.AutoViz_Utils import *
  import copy
  import warnings
  import logging
  import warnings
  from sklearn.exceptions import DataConversionWarning
  import matplotlib
  import matplotlib.pyplot
  import io
  import seaborn
  import re
  import pdb
  import pprint
  import matplotlib
  from itertools import cycle, combinations
  from collections import defaultdict
  import copy
  import time
  import sys
  import random
  import xlrd
  import statsmodels
  from io import BytesIO
  import base64
  from functools import reduce
  import traceback
  import xgboost
  from xgboost.sklearn import XGBClassifier
  from xgboost.sklearn import XGBRegressor
  import os
  from .classify_method import classify_columns
label_desc: Use image node_id 12 for calling a global function with example usage: draw_scatters_hv(dft, nums, chart_format, problem_type, dep, classes, lowess, mk_dir, verbose) and returns: hv_all, hv, hv