import torch import gradio as gr from transformers import BertTokenizer, BertForSequenceClassification import matplotlib.pyplot as plt import numpy as np from wordcloud import WordCloud from collections import Counter, defaultdict import re import json import csv import io import tempfile from datetime import datetime import logging from functools import lru_cache, wraps from dataclasses import dataclass from typing import List, Dict, Optional, Tuple, Any, Callable from contextlib import contextmanager import gc import pandas as pd from lime.lime_text import LimeTextExplainer import shap import base64 @dataclass class _C7x9: _m1: int = 1000 _b2: int = 50 _t3: int = 512 _w4: int = 2 _c5: int = 128 _p6: int = 8 _fs1: Tuple[int, int] = (8, 5) _fs2: Tuple[int, int] = (12, 8) _ws: Tuple[int, int] = (10, 5) _th = { 'default': {'pos': '#4ecdc4', 'neg': '#ff6b6b'}, 'ocean': {'pos': '#0077be', 'neg': '#ff6b35'}, 'forest': {'pos': '#228b22', 'neg': '#dc143c'}, 'sunset': {'pos': '#ff8c00', 'neg': '#8b0000'} } _sw = { 'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by', 'is', 'are', 'was', 'were', 'be', 'been', 'have', 'has', 'had', 'will', 'would', 'could', 'should' } _cfg = _C7x9() _log = logging.getLogger(__name__) def _err_wrap(_def_ret=None): def _dec(_func: Callable) -> Callable: @wraps(_func) def _wrap(*args, **kwargs): try: return _func(*args, **kwargs) except Exception as e: _log.error(f"{_func.__name__} failed: {e}") return _def_ret if _def_ret is not None else f"Error: {str(e)}" return _wrap return _dec @contextmanager def _fig_mgr(*args, **kwargs): _f = plt.figure(*args, **kwargs) try: yield _f finally: plt.close(_f) gc.collect() class _Th7: def __init__(self, _t: str = 'default'): self._t = _t self._c = _cfg._th.get(_t, _cfg._th['default']) class _MM9: _inst = None _mdl = None _tok = None _dev = None def __new__(cls): if cls._inst is None: cls._inst = super().__new__(cls) return cls._inst @property def _m(self): if self._mdl is None: self._load() return self._mdl @property def _t(self): if self._tok is None: self._load() return self._tok @property def _d(self): if self._dev is None: self._dev = torch.device("cuda" if torch.cuda.is_available() else "cpu") return self._dev def _load(self): try: self._dev = torch.device("cuda" if torch.cuda.is_available() else "cpu") _mp = base64.b64decode("ZW50cm9weTI1L3NlbnRpbWVudGFuYWx5c2lz").decode() self._tok = BertTokenizer.from_pretrained(_mp) self._mdl = BertForSequenceClassification.from_pretrained(_mp) self._mdl.to(self._dev) _log.info(f"Model loaded on {self._dev}") except Exception as e: _log.error(f"Model loading failed: {e}") raise class _TP8: @staticmethod @lru_cache(maxsize=_cfg._c5) def _clean(_txt: str) -> Tuple[str, ...]: _w = re.findall(r'\b\w{3,}\b', _txt.lower()) return tuple(w for w in _w if w not in _cfg._sw) class _HM2: def __init__(self): self._h = [] def _add(self, _e: Dict): self._h.append({**_e, 'timestamp': datetime.now().isoformat()}) if len(self._h) > _cfg._m1: self._h = self._h[-_cfg._m1:] def _get(self) -> List[Dict]: return self._h.copy() def _clr(self) -> int: _cnt = len(self._h) self._h.clear() return _cnt def _sz(self) -> int: return len(self._h) class _SE3: def __init__(self): self._mm = _MM9() self._le = LimeTextExplainer(class_names=['Negative', 'Positive']) self._se = None def _pred(self, _txts): if isinstance(_txts, str): _txts = [_txts] _inp = self._mm._t( _txts, return_tensors="pt", padding=True, truncation=True, max_length=_cfg._t3 ).to(self._mm._d) with torch.no_grad(): _out = self._mm._m(**_inp) _probs = torch.nn.functional.softmax(_out.logits, dim=-1).cpu().numpy() return _probs @_err_wrap({'sentiment': 'Unknown', 'confidence': 0.0}) def _fast(self, _txt: str) -> Dict: if not _txt.strip(): raise ValueError("Empty text") _probs = self._pred([_txt])[0] _sent = "Positive" if _probs[1] > _probs[0] else "Negative" return { 'sentiment': _sent, 'confidence': float(_probs.max()), 'pos_prob': float(_probs[1]), 'neg_prob': float(_probs[0]) } def _lime_kw(self, _txt: str, _k: int = 10) -> List[Tuple[str, float]]: try: _exp = self._le.explain_instance( _txt, self._pred, num_features=_k, num_samples=200 ) _ws = [] for _w, _s in _exp.as_list(): if len(_w.strip()) >= _cfg._w4: _ws.append((_w.strip().lower(), abs(_s))) _ws.sort(key=lambda x: x[1], reverse=True) return _ws[:_k] except Exception as e: _log.error(f"LIME extraction failed: {e}") return [] def _shap_kw(self, _txt: str, _k: int = 10) -> List[Tuple[str, float]]: try: _words = _txt.split() _ws = [] _base = self._pred([_txt])[0][1] for i, _w in enumerate(_words): _mod_w = _words[:i] + _words[i+1:] _mod_t = ' '.join(_mod_w) if _mod_t.strip(): _mod_p = self._pred([_mod_t])[0][1] _imp = abs(_base - _mod_p) _clean_w = re.sub(r'[^\w]', '', _w.lower()) if len(_clean_w) >= _cfg._w4: _ws.append((_clean_w, _imp)) _uniq = {} for _w, _s in _ws: if _w in _uniq: _uniq[_w] = max(_uniq[_w], _s) else: _uniq[_w] = _s _sorted = sorted(_uniq.items(), key=lambda x: x[1], reverse=True) return _sorted[:_k] except Exception as e: _log.error(f"SHAP extraction failed: {e}") return [] def _heatmap(self, _txt: str, _ws: Dict[str, float]) -> str: _words = _txt.split() _html = ['
'] if _ws: _max = max(abs(_s) for _s in _ws.values()) _min = min(_ws.values()) else: _max = _min = 0 for _w in _words: _clean = re.sub(r'[^\w]', '', _w.lower()) _score = _ws.get(_clean, 0) if _score > 0: _int = min(255, int(180 * (_score / _max) if _max > 0 else 0)) _color = f"rgba(0, {_int}, 0, 0.3)" elif _score < 0: _int = min(255, int(180 * (abs(_score) / abs(_min)) if _min < 0 else 0)) _color = f"rgba({_int}, 0, 0, 0.3)" else: _color = "transparent" _html.append( f'{_w} ' ) _html.append('
') return ''.join(_html) @_err_wrap({'sentiment': 'Unknown', 'confidence': 0.0, 'lime_words': [], 'shap_words': [], 'heatmap_html': ''}) def _adv(self, _txt: str) -> Dict: if not _txt.strip(): raise ValueError("Empty text") _probs = self._pred([_txt])[0] _sent = "Positive" if _probs[1] > _probs[0] else "Negative" _lime = self._lime_kw(_txt) _shap = self._shap_kw(_txt) _ws_dict = dict(_lime) _heat = self._heatmap(_txt, _ws_dict) return { 'sentiment': _sent, 'confidence': float(_probs.max()), 'pos_prob': float(_probs[1]), 'neg_prob': float(_probs[0]), 'lime_words': _lime, 'shap_words': _shap, 'heatmap_html': _heat } @_err_wrap([]) def _batch(self, _txts: List[str], _prog=None) -> List[Dict]: if len(_txts) > _cfg._b2: _txts = _txts[:_cfg._b2] _res = [] _bs = _cfg._p6 for i in range(0, len(_txts), _bs): _b = _txts[i:i+_bs] if _prog: _prog((i + len(_b)) / len(_txts)) _inp = self._mm._t( _b, return_tensors="pt", padding=True, truncation=True, max_length=_cfg._t3 ).to(self._mm._d) with torch.no_grad(): _out = self._mm._m(**_inp) _probs = torch.nn.functional.softmax(_out.logits, dim=-1).cpu().numpy() for _txt, _prob in zip(_b, _probs): _sent = "Positive" if _prob[1] > _prob[0] else "Negative" _res.append({ 'text': _txt[:50] + '...' if len(_txt) > 50 else _txt, 'full_text': _txt, 'sentiment': _sent, 'confidence': float(_prob.max()), 'pos_prob': float(_prob[1]), 'neg_prob': float(_prob[0]) }) return _res class _PF4: @staticmethod @_err_wrap(None) def _bars(_probs: np.ndarray, _th: _Th7) -> plt.Figure: with _fig_mgr(figsize=_cfg._fs1) as _f: _ax = _f.add_subplot(111) _lbl = ["Negative", "Positive"] _clr = [_th._c['neg'], _th._c['pos']] _b = _ax.bar(_lbl, _probs, color=_clr, alpha=0.8) _ax.set_title("Sentiment Probabilities", fontweight='bold') _ax.set_ylabel("Probability") _ax.set_ylim(0, 1) for _bar, _prob in zip(_b, _probs): _ax.text(_bar.get_x() + _bar.get_width()/2., _bar.get_height() + 0.02, f'{_prob:.3f}', ha='center', va='bottom', fontweight='bold') _f.tight_layout() return _f @staticmethod @_err_wrap(None) def _gauge(_conf: float, _sent: str, _th: _Th7) -> plt.Figure: with _fig_mgr(figsize=_cfg._fs1) as _f: _ax = _f.add_subplot(111) _theta = np.linspace(0, np.pi, 100) _clr = [_th._c['neg'] if i < 50 else _th._c['pos'] for i in range(100)] for i in range(len(_theta)-1): _ax.fill_between([_theta[i], _theta[i+1]], [0, 0], [0.8, 0.8], color=_clr[i], alpha=0.7) _pos = np.pi * (0.5 + (0.4 if _sent == 'Positive' else -0.4) * _conf) _ax.plot([_pos, _pos], [0, 0.6], 'k-', linewidth=6) _ax.plot(_pos, 0.6, 'ko', markersize=10) _ax.set_xlim(0, np.pi) _ax.set_ylim(0, 1) _ax.set_title(f'{_sent} - Confidence: {_conf:.3f}', fontweight='bold') _ax.set_xticks([0, np.pi/2, np.pi]) _ax.set_xticklabels(['Negative', 'Neutral', 'Positive']) _ax.axis('off') _f.tight_layout() return _f @staticmethod @_err_wrap(None) def _lime_chart(_lw: List[Tuple[str, float]], _sent: str, _th: _Th7) -> Optional[plt.Figure]: if not _lw: return None with _fig_mgr(figsize=_cfg._fs1) as _f: _ax = _f.add_subplot(111) _w = [_word for _word, _score in _lw] _s = [_score for _word, _score in _lw] _clr = _th._c['pos'] if _sent == 'Positive' else _th._c['neg'] _b = _ax.barh(range(len(_w)), _s, color=_clr, alpha=0.7) _ax.set_yticks(range(len(_w))) _ax.set_yticklabels(_w) _ax.set_xlabel('LIME Attention Weight') _ax.set_title(f'LIME: Top Contributing Words ({_sent})', fontweight='bold') for i, (_bar, _score) in enumerate(zip(_b, _s)): _ax.text(_bar.get_width() + 0.001, _bar.get_y() + _bar.get_height()/2., f'{_score:.3f}', ha='left', va='center', fontsize=9) _ax.invert_yaxis() _ax.grid(axis='x', alpha=0.3) _f.tight_layout() return _f @staticmethod @_err_wrap(None) def _shap_chart(_sw: List[Tuple[str, float]], _sent: str, _th: _Th7) -> Optional[plt.Figure]: if not _sw: return None with _fig_mgr(figsize=_cfg._fs1) as _f: _ax = _f.add_subplot(111) _w = [_word for _word, _score in _sw] _s = [_score for _word, _score in _sw] _clr = _th._c['pos'] if _sent == 'Positive' else _th._c['neg'] _b = _ax.barh(range(len(_w)), _s, color=_clr, alpha=0.7) _ax.set_yticks(range(len(_w))) _ax.set_yticklabels(_w) _ax.set_xlabel('SHAP Value') _ax.set_title(f'SHAP: Top Contributing Words ({_sent})', fontweight='bold') for i, (_bar, _score) in enumerate(zip(_b, _s)): _ax.text(_bar.get_width() + 0.001, _bar.get_y() + _bar.get_height()/2., f'{_score:.3f}', ha='left', va='center', fontsize=9) _ax.invert_yaxis() _ax.grid(axis='x', alpha=0.3) _f.tight_layout() return _f @staticmethod @_err_wrap(None) def _cloud(_txt: str, _sent: str, _th: _Th7) -> Optional[plt.Figure]: if len(_txt.split()) < 3: return None _cm = 'Greens' if _sent == 'Positive' else 'Reds' _wc = WordCloud(width=800, height=400, background_color='white', colormap=_cm, max_words=30).generate(_txt) with _fig_mgr(figsize=_cfg._ws) as _f: _ax = _f.add_subplot(111) _ax.imshow(_wc, interpolation='bilinear') _ax.axis('off') _ax.set_title(f'{_sent} Word Cloud', fontweight='bold') _f.tight_layout() return _f @staticmethod @_err_wrap(None) def _batch_viz(_res: List[Dict], _th: _Th7) -> plt.Figure: with _fig_mgr(figsize=_cfg._fs2) as _f: _gs = _f.add_gridspec(2, 2, hspace=0.3, wspace=0.3) _ax1 = _f.add_subplot(_gs[0, 0]) _sc = Counter([_r['sentiment'] for _r in _res]) _clr = [_th._c['pos'], _th._c['neg']] _ax1.pie(_sc.values(), labels=_sc.keys(), autopct='%1.1f%%', colors=_clr[:len(_sc)]) _ax1.set_title('Sentiment Distribution') _ax2 = _f.add_subplot(_gs[0, 1]) _confs = [_r['confidence'] for _r in _res] _ax2.hist(_confs, bins=8, alpha=0.7, color='skyblue', edgecolor='black') _ax2.set_title('Confidence Distribution') _ax2.set_xlabel('Confidence') _ax3 = _f.add_subplot(_gs[1, :]) _pp = [_r['pos_prob'] for _r in _res] _idx = range(len(_res)) _cs = [_th._c['pos'] if _r['sentiment'] == 'Positive' else _th._c['neg'] for _r in _res] _ax3.scatter(_idx, _pp, c=_cs, alpha=0.7, s=60) _ax3.axhline(y=0.5, color='gray', linestyle='--', alpha=0.5) _ax3.set_title('Sentiment Progression') _ax3.set_xlabel('Review Index') _ax3.set_ylabel('Positive Probability') return _f class _DH5: @staticmethod @_err_wrap((None, "Export failed")) def _exp(_data: List[Dict], _fmt: str) -> Tuple[Optional[str], str]: if not _data: return None, "No data to export" _tf = tempfile.NamedTemporaryFile(mode='w', delete=False, suffix=f'.{_fmt}', encoding='utf-8') if _fmt == 'csv': _w = csv.writer(_tf) _w.writerow(['Timestamp', 'Text', 'Sentiment', 'Confidence', 'Pos_Prob', 'Neg_Prob']) for _e in _data: _w.writerow([ _e.get('timestamp', ''), _e.get('text', ''), _e.get('sentiment', ''), f"{_e.get('confidence', 0):.4f}", f"{_e.get('pos_prob', 0):.4f}", f"{_e.get('neg_prob', 0):.4f}" ]) elif _fmt == 'json': json.dump(_data, _tf, indent=2, ensure_ascii=False) _tf.close() return _tf.name, f"Exported {len(_data)} entries" @staticmethod @_err_wrap("") def _proc(_file) -> str: if not _file: return "" try: _fp = _file.name if _fp.endswith('.csv'): for _enc in ['utf-8', 'latin-1', 'cp1252', 'iso-8859-1']: try: _df = pd.read_csv(_fp, encoding=_enc) _tc = [] for _col in _df.columns: _sv = _df[_col].dropna().head(10) if len(_sv) > 0: _cnt = sum(1 for _val in _sv if isinstance(_val, str) and len(str(_val).strip()) > 10) if _cnt > len(_sv) * 0.7: _tc.append(_col) if _tc: _sc = _tc[0] else: _sc = _df.columns[0] _rev = _df[_sc].dropna().astype(str).tolist() _cr = [] for _r in _rev: _r = _r.strip() if len(_r) > 10 and _r.lower() != 'nan': _cr.append(_r) if _cr: _log.info(f"Successfully read {len(_cr)} reviews from CSV") return '\n'.join(_cr) except Exception as e: continue return "Error: Could not read CSV file. Please check the file format and encoding." else: for _enc in ['utf-8', 'latin-1', 'cp1252']: try: with open(_fp, 'r', encoding=_enc) as _f: _cont = _f.read().strip() if _cont: return _cont except Exception as e: continue return "Error: Could not read text file. Please check the file encoding." except Exception as e: _log.error(f"File processing error: {e}") return f"Error processing file: {str(e)}" class _SA6: def __init__(self): self._eng = _SE3() self._hist = _HM2() self._dh = _DH5() self._ex = [ ["While the film's visual effects were undeniably impressive, the story lacked emotional weight, and the pacing felt inconsistent throughout."], ["An extraordinary achievement in filmmaking — the direction was masterful, the script was sharp, and every performance added depth and realism."], ["Despite a promising start, the film quickly devolved into a series of clichés, with weak character development and an ending that felt rushed and unearned."], ["A beautifully crafted story with heartfelt moments and a soundtrack that perfectly captured the emotional tone of each scene."], ["The movie was far too long, with unnecessary subplots and dull dialogue that made it difficult to stay engaged until the end."] ] @_err_wrap(("Please enter text", None, None, None)) def _fast_ana(self, _txt: str, _th: str = 'default'): if not _txt.strip(): return "Please enter text", None, None, None _res = self._eng._fast(_txt) self._hist._add({ 'text': _txt[:100], 'full_text': _txt, **_res }) _thc = _Th7(_th) _probs = np.array([_res['neg_prob'], _res['pos_prob']]) _pp = _PF4._bars(_probs, _thc) _gp = _PF4._gauge(_res['confidence'], _res['sentiment'], _thc) _cp = _PF4._cloud(_txt, _res['sentiment'], _thc) _rt = f"Sentiment: {_res['sentiment']} (Confidence: {_res['confidence']:.3f})" return _rt, _pp, _gp, _cp @_err_wrap(("Please enter text", None, None, None)) def _adv_ana(self, _txt: str, _th: str = 'default'): if not _txt.strip(): return "Please enter text", None, None, None _res = self._eng._adv(_txt) self._hist._add({ 'text': _txt[:100], 'full_text': _txt, **_res }) _thc = _Th7(_th) _lp = _PF4._lime_chart(_res['lime_words'], _res['sentiment'], _thc) _sp = _PF4._shap_chart(_res['shap_words'], _res['sentiment'], _thc) _lws = ", ".join([f"{_w}({_s:.3f})" for _w, _s in _res['lime_words'][:5]]) _sws = ", ".join([f"{_w}({_s:.3f})" for _w, _s in _res['shap_words'][:5]]) _rt = (f"Sentiment: {_res['sentiment']} (Confidence: {_res['confidence']:.3f})\n" f"LIME Key Words: {_lws}\n" f"SHAP Key Words: {_sws}") return _rt, _lp, _sp, _res['heatmap_html'] @_err_wrap(None) def _batch_ana(self, _revs: str, _prog=None): if not _revs.strip(): return None _txts = [_r.strip() for _r in _revs.split('\n') if _r.strip()] if len(_txts) < 2: return None _res = self._eng._batch(_txts, _prog) for _r in _res: self._hist._add(_r) _thc = _Th7('default') return _PF4._batch_viz(_res, _thc) @_err_wrap((None, "No history available")) def _hist_plot(self, _th: str = 'default'): _hist = self._hist._get() if len(_hist) < 2: return None, f"Need at least 2 analyses for trends. Current: {len(_hist)}" _thc = _Th7(_th) with _fig_mgr(figsize=(12, 8)) as _f: _gs = _f.add_gridspec(2, 1, hspace=0.3) _idx = list(range(len(_hist))) _pp = [_item['pos_prob'] for _item in _hist] _confs = [_item['confidence'] for _item in _hist] _ax1 = _f.add_subplot(_gs[0, 0]) _clr = [_thc._c['pos'] if _p > 0.5 else _thc._c['neg'] for _p in _pp] _ax1.scatter(_idx, _pp, c=_clr, alpha=0.7, s=60) _ax1.plot(_idx, _pp, alpha=0.5, linewidth=2) _ax1.axhline(y=0.5, color='gray', linestyle='--', alpha=0.5) _ax1.set_title('Sentiment History') _ax1.set_ylabel('Positive Probability') _ax1.grid(True, alpha=0.3) _ax2 = _f.add_subplot(_gs[1, 0]) _ax2.bar(_idx, _confs, alpha=0.7, color='lightblue', edgecolor='navy') _ax2.set_title('Confidence Over Time') _ax2.set_xlabel('Analysis Number') _ax2.set_ylabel('Confidence') _ax2.grid(True, alpha=0.3) _f.tight_layout() return _f, f"History: {len(_hist)} analyses" def _create_ui(): _app = _SA6() with gr.Blocks(theme=gr.themes.Soft(), title="Movie Sentiment Analyzer") as _demo: gr.Markdown("# 🎬 AI Movie Sentiment Analyzer") gr.Markdown("Fast sentiment analysis with advanced deep learning explanations") with gr.Tab("Quick Analysis"): with gr.Row(): with gr.Column(): _ti = gr.Textbox( label="Movie Review", placeholder="Enter your movie review...", lines=5 ) with gr.Row(): _ab = gr.Button("Analyze", variant="primary") _ts = gr.Dropdown( choices=list(_cfg._th.keys()), value="default", label="Theme" ) gr.Examples( examples=_app._ex, inputs=_ti ) with gr.Column(): _ro = gr.Textbox(label="Result", lines=3) with gr.Row(): _pp = gr.Plot(label="Probabilities") _gp = gr.Plot(label="Confidence") with gr.Row(): _wp = gr.Plot(label="Word Cloud") with gr.Tab("Advanced Analysis"): with gr.Row(): with gr.Column(): _ati = gr.Textbox( label="Movie Review", placeholder="Enter your movie review for deep analysis...", lines=5 ) with gr.Row(): _aab = gr.Button("Deep Analyze", variant="primary") _ats = gr.Dropdown( choices=list(_cfg._th.keys()), value="default", label="Theme" ) gr.Examples( examples=_app._ex, inputs=_ati ) with gr.Column(): _aro = gr.Textbox(label="Analysis Result", lines=4) with gr.Row(): _lp = gr.Plot(label="LIME: Key Contributing Words") _sp = gr.Plot(label="SHAP: Key Contributing Words") with gr.Row(): _ho = gr.HTML(label="Word Importance Heatmap (LIME-based)") with gr.Tab("Batch Analysis"): with gr.Row(): with gr.Column(): _fu = gr.File(label="Upload File", file_types=[".csv", ".txt"]) _bi = gr.Textbox( label="Reviews (one per line)", lines=8 ) with gr.Column(): _lb = gr.Button("Load File") _bb = gr.Button("Analyze Batch", variant="primary") _bp = gr.Plot(label="Batch Results") with gr.Tab("History & Export"): with gr.Row(): _rb = gr.Button("Refresh") _cb = gr.Button("Clear", variant="stop") with gr.Row(): _csvb = gr.Button("Export CSV") _jb = gr.Button("Export JSON") _hs = gr.Textbox(label="Status") _hp = gr.Plot(label="History Trends") _csvf = gr.File(label="CSV Download", visible=True) _jf = gr.File(label="JSON Download", visible=True) # Event handlers _ab.click( _app._fast_ana, inputs=[_ti, _ts], outputs=[_ro, _pp, _gp, _wp] ) _aab.click( _app._adv_ana, inputs=[_ati, _ats], outputs=[_aro, _lp, _sp, _ho] ) _lb.click(_app._dh._proc, inputs=_fu, outputs=_bi) _bb.click(_app._batch_ana, inputs=_bi, outputs=_bp) _rb.click( lambda _th: _app._hist_plot(_th), inputs=_ts, outputs=[_hp, _hs] ) _cb.click( lambda: f"Cleared {_app._hist._clr()} entries", outputs=_hs ) _csvb.click( lambda: _app._dh._exp(_app._hist._get(), 'csv'), outputs=[_csvf, _hs] ) _jb.click( lambda: _app._dh._exp(_app._hist._get(), 'json'), outputs=[_jf, _hs] ) return _demo if __name__ == "__main__": logging.basicConfig(level=logging.INFO) _demo = _create_ui() _demo.launch(share=True)