code: def draw_semantic_network(
      graph,
      *,
      node_weights=None,
      spread=3.0,
      draw_nodes=False,
      base_node_size=300,
      node_alpha=0.25,
      line_width=0.5,
      line_alpha=0.1,
      base_font_size=12,
      save=False,
  ):
      """
      Draw a semantic network with nodes representing either terms or sentences,
      edges representing coocurrence or similarity, and positions given by a force-
      directed layout.
  
      Args:
          graph (``networkx.Graph``):
          node_weights (dict): mapping of node: weight, used to size node labels
              (and, optionally, node circles) according to their weight
          spread (float): number that drives the spread of the network; higher
              values give more spread-out networks
          draw_nodes (bool): if True, circles are drawn under the node labels
          base_node_size (int): if `node_weights` not given and `draw_nodes` is True,
              this is the size of all nodes in the network; if `node_weights` _is_
              given, node sizes will be scaled against this value based on their
              weights compared to the max weight
          node_alpha (float): alpha of the circular nodes drawn behind labels if
              `draw_nodes` is True
          line_width (float): width of the lines (edges) drawn between nodes
          line_alpha (float): alpha of the lines (edges) drawn between nodes
          base_font_size (int): if `node_weights` not given, this is the font size
              used to draw all labels; otherwise, font sizes will be scaled against
              this value based on the corresponding node weights compared to the max
          save (str): give the full /path/to/fname on disk to save figure (optional)
  
      Returns:
          :obj:`matplotlib.axes.Axes.axis`: Axis on which network plot is drawn.
  
      Note:
          This function requires `matplotlib <https://matplotlib.org/>`_.
      """
      try:
          plt
      except NameError:
          raise ImportError(
              "`matplotlib` is not installed, so `textacy.viz` won't work; "
              "install it individually via `$ pip install matplotlib`, or "
              "along with textacy via `pip install textacy[viz]`."
          )
      with plt.rc_context(RC_PARAMS):
          fig, ax = plt.subplots(figsize=(12, 12))
  
          pos = nx.layout.spring_layout(
              graph, k=spread / math.sqrt(len(graph.nodes()))
          )
          _ = nx.draw_networkx_edges(
              graph,
              ax=ax,
              pos=pos,
              width=line_width,
              alpha=line_alpha,
              arrows=False,
          )
  
          if node_weights is None:
              if draw_nodes is True:
                  _ = nx.draw_networkx_nodes(
                      graph,
                      ax=ax,
                      pos=pos,
                      alpha=node_alpha,
                      linewidths=0.5,
                      node_size=base_node_size,
                  )
              _ = nx.draw_networkx_labels(
                  graph,
                  pos,
                  ax=ax,
                  font_size=base_font_size,
                  font_color="black",
                  font_family="sans-serif",
              )
          else:
              max_node_weight = max(node_weights.values())
              if draw_nodes is True:
                  node_sizes = [
                      base_node_size
                      * pow(node_weights[node] / max_node_weight, 0.75)
                      for node in graph.nodes()
                  ]
                  _ = nx.draw_networkx_nodes(
                      graph,
                      ax=ax,
                      pos=pos,
                      node_size=node_sizes,
                      alpha=node_alpha,
                      linewidths=0.5,
                  )
              for node, weight in node_weights.items():
                  _ = nx.draw_networkx_labels(
                      graph,
                      pos,
                      labels={node: node},
                      ax=ax,
                      font_color="black",
                      font_family="sans-serif",
                      font_size=base_font_size
                      * pow(weight / max_node_weight, 0.15),
                  )
  
          ax.set_frame_on(False)
          ax.set_xticklabels(
              ["" for _ in range(len(ax.get_xticklabels()))]
          )
          ax.set_yticklabels(
              ["" for _ in range(len(ax.get_yticklabels()))]
          )
  
      if save:
          fig.savefig(save, bbox_inches="tight", dpi=100)
  
      return ax
  
label_desc: Use image node_id 1 for calling a global function with example usage: draw_semantic_network(graph) and returns: ax