code: import json
  import plotly
  import pandas as pd
  import nltk
  from nltk.stem import WordNetLemmatizer
  from nltk.tokenize import word_tokenize, sent_tokenize
  from nltk import pos_tag, word_tokenize
  from nltk.stem import WordNetLemmatizer
  from nltk.tokenize import word_tokenize
  
  from flask import Flask
  from flask import render_template, request, jsonify
  from plotly.graph_objs import Bar
  from sklearn.base import BaseEstimator, TransformerMixin
  
  import joblib
  from sqlalchemy import create_engine
  
  
  app = Flask(__name__)
  
  class StartingVerbExtractor(BaseEstimator, TransformerMixin):
      
      def starting_verb(self, text):
          sentence_list = nltk.sent_tokenize(text)
          for sentence in sentence_list:
              pos_tags = nltk.pos_tag(tokenize(sentence))
              first_word, first_tag = pos_tags[0]
              if first_tag in ['VB', 'VBP'] or first_word == 'RT':
                  return True
          return False
  
      def fit(self, X, y=None):
          return self
  
      def transform(self, X):
          X_tagged = pd.Series(X).apply(self.starting_verb)
          return pd.DataFrame(X_tagged)
  
  
  def tokenize(text):
      tokens = word_tokenize(text)
      lemmatizer = WordNetLemmatizer()
  
      clean_tokens = []
      for tok in tokens:
          clean_tok = lemmatizer.lemmatize(tok).lower().strip()
          clean_tokens.append(clean_tok)
  
      return clean_tokens
  
  # load data
  engine = create_engine('sqlite:///../data/disaster_response.db')
  df = pd.read_sql_table('disaster_response_table', engine)
  
  # load model
  model = joblib.load("../models/classifier.pkl")
  
  
  # index webpage displays cool visuals and receives user input text for model
  @app.route('/')
  @app.route('/index')
  def index():
       # extract data needed for visuals
      # TODO: Below is an example - modify to extract data for your own visuals
      genre_counts = df.groupby('genre').count()['message']
      genre_percent = round(100*genre_counts/genre_counts.sum(), 2)
      genre_names = list(genre_counts.index)
  
      category_names = df.iloc[:,4:].columns
      category_boolean = (df.iloc[:,4:] != 0).sum().values
  
      # create visuals
      # TODO: Below is an example - modify to create your own visuals
      graphs = [
              # GRAPH 1 - genre graph
          {
              "data": [
                {
                  "type": "pie",
                  "uid": "f4de1f",
                  "hole": 0.4,
                  "name": "Genre",
                  "pull": 0,
                  "domain": {
                    "x": genre_percent,
                    "y": genre_names
                  },
                  "marker": {
                    "colors": [
                      "#7fc97f",
                      "#bc5090",
                      "#ffa600"
                     ]
                  },
                  "textinfo": "label+value",
                  "hoverinfo": "all",
                  "labels": genre_names,
                  "values": genre_counts
                }
              ],
              "layout": {
                "title": "Count and Percentage of Messages by Genre"
              }
          },
              # GRAPH 2 - category graph
          {
              'data': [
                  Bar(
                      x=category_names,
                      y=category_boolean
                  )
              ],
  
              'layout': {
                  'title': 'Distribution of Message Categories',
                  'yaxis': {
                      'title': "Count"
                  },
                  'xaxis': {
                      'title': "Category",
                      'tickangle': 35
                  }
              }
          }
      ]
  
      # encode plotly graphs in JSON
      ids = ["graph-{}".format(i) for i, _ in enumerate(graphs)]
      graphJSON = json.dumps(graphs, cls=plotly.utils.PlotlyJSONEncoder)
  
      # render web page with plotly graphs
      return render_template('master.html', ids=ids, graphJSON=graphJSON)
  
  # web page that handles user query and displays model results
  @app.route('/go')
  def go():
      # save user input in query
      query = request.args.get('query', '')
  
      # use model to predict classification for query
      classification_labels = model.predict([query])[0]
      classification_results = dict(zip(df.columns[4:], classification_labels))
  
      # This will render the go.html Please see that file. 
      return render_template(
          'go.html',
          query=query,
          classification_result=classification_results
      )
  
  
  def main():
      app.run(host='0.0.0.0', port=5000, debug=True)
  
  
  if __name__ == '__main__':
      main()
apis: pandas.read_sql_table pandas.Series pandas.DataFrame