whisper_podcast_subtitles.ipynb

{
  "cells": [
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "73JHCOCS99hl"
      },
      "source": [
        "# 生成Apple PodCast字幕 / Apple PodCast Transcription with OpenAI's Whisper\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mBUm1pmC90Mk",
        "outputId": "8075b665-c0d4-42e6-a2e9-6b4df6addb3f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "GPU 0: Tesla T4 (UUID: GPU-2bba1763-1e76-7de5-21dd-28696164c1f1)\n",
            "Sat Mar 25 18:14:59 2023       \n",
            "+-----------------------------------------------------------------------------+\n",
            "| NVIDIA-SMI 525.85.12    Driver Version: 525.85.12    CUDA Version: 12.0     |\n",
            "|-------------------------------+----------------------+----------------------+\n",
            "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
            "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
            "|                               |                      |               MIG M. |\n",
            "|===============================+======================+======================|\n",
            "|   0  Tesla T4            Off  | 00000000:00:04.0 Off |                    0 |\n",
            "| N/A   70C    P8    10W /  70W |      0MiB / 15360MiB |      0%      Default |\n",
            "|                               |                      |                  N/A |\n",
            "+-------------------------------+----------------------+----------------------+\n",
            "                                                                               \n",
            "+-----------------------------------------------------------------------------+\n",
            "| Processes:                                                                  |\n",
            "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
            "|        ID   ID                                                   Usage      |\n",
            "|=============================================================================|\n",
            "|  No running processes found                                                 |\n",
            "+-----------------------------------------------------------------------------+\n"
          ]
        }
      ],
      "source": [
        "#@markdown # **Check GPU type** 🕵️\n",
        "\n",
        "#@markdown The type of GPU you get assigned in your Colab session defined the speed at which the video will be transcribed.\n",
        "#@markdown The higher the number of floating point operations per second (FLOPS), the faster the transcription.\n",
        "#@markdown But even the least powerful GPU available in Colab is able to run any Whisper model.\n",
        "#@markdown Make sure you've selected `GPU` as hardware accelerator for the Notebook (Runtime → Change runtime type → Hardware accelerator).\n",
        "\n",
        "#@markdown |  GPU   |  GPU RAM   | FP32 teraFLOPS |     Availability   |\n",
        "#@markdown |:------:|:----------:|:--------------:|:------------------:|\n",
        "#@markdown |  T4    |    16 GB   |       8.1      |         Free       |\n",
        "#@markdown | P100   |    16 GB   |      10.6      |      Colab Pro     |\n",
        "#@markdown | V100   |    16 GB   |      15.7      |  Colab Pro (Rare)  |\n",
        "\n",
        "#@markdown ---\n",
        "#@markdown **Factory reset your Notebook's runtime if you want to get assigned a new GPU.**\n",
        "\n",
        "!nvidia-smi -L\n",
        "\n",
        "!nvidia-smi\n",
        "     "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZMRtV2Lw_BHU",
        "outputId": "e97ac379-971b-40cf-a95f-227a2e1f2296"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting git+https://github.com/openai/whisper.git\n",
            "  Cloning https://github.com/openai/whisper.git to /tmp/pip-req-build-5o9tc7ht\n",
            "  Running command git clone --filter=blob:none --quiet https://github.com/openai/whisper.git /tmp/pip-req-build-5o9tc7ht\n",
            "  Resolved https://github.com/openai/whisper.git to commit 6dea21fd7f7253bfe450f1e2512a0fe47ee2d258\n",
            "  Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n",
            "  Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n",
            "  Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
            "Collecting tiktoken==0.3.1\n",
            "  Downloading tiktoken-0.3.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.7 MB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.7/1.7 MB\u001b[0m \u001b[31m57.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hCollecting triton==2.0.0\n",
            "  Downloading triton-2.0.0-1-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl (63.3 MB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m63.3/63.3 MB\u001b[0m \u001b[31m11.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: tqdm in /usr/local/lib/python3.9/dist-packages (from openai-whisper==20230314) (4.65.0)\n",
            "Requirement already satisfied: torch in /usr/local/lib/python3.9/dist-packages (from openai-whisper==20230314) (1.13.1+cu116)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.9/dist-packages (from openai-whisper==20230314) (1.22.4)\n",
            "Requirement already satisfied: numba in /usr/local/lib/python3.9/dist-packages (from openai-whisper==20230314) (0.56.4)\n",
            "Requirement already satisfied: more-itertools in /usr/local/lib/python3.9/dist-packages (from openai-whisper==20230314) (9.1.0)\n",
            "Collecting ffmpeg-python==0.2.0\n",
            "  Downloading ffmpeg_python-0.2.0-py3-none-any.whl (25 kB)\n",
            "Requirement already satisfied: future in /usr/local/lib/python3.9/dist-packages (from ffmpeg-python==0.2.0->openai-whisper==20230314) (0.18.3)\n",
            "Requirement already satisfied: requests>=2.26.0 in /usr/local/lib/python3.9/dist-packages (from tiktoken==0.3.1->openai-whisper==20230314) (2.27.1)\n",
            "Requirement already satisfied: regex>=2022.1.18 in /usr/local/lib/python3.9/dist-packages (from tiktoken==0.3.1->openai-whisper==20230314) (2022.10.31)\n",
            "Requirement already satisfied: cmake in /usr/local/lib/python3.9/dist-packages (from triton==2.0.0->openai-whisper==20230314) (3.25.2)\n",
            "Requirement already satisfied: filelock in /usr/local/lib/python3.9/dist-packages (from triton==2.0.0->openai-whisper==20230314) (3.10.1)\n",
            "Collecting lit\n",
            "  Downloading lit-16.0.0.tar.gz (144 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m145.0/145.0 KB\u001b[0m \u001b[31m19.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "Requirement already satisfied: setuptools in /usr/local/lib/python3.9/dist-packages (from numba->openai-whisper==20230314) (67.6.0)\n",
            "Requirement already satisfied: llvmlite<0.40,>=0.39.0dev0 in /usr/local/lib/python3.9/dist-packages (from numba->openai-whisper==20230314) (0.39.1)\n",
            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.9/dist-packages (from torch->openai-whisper==20230314) (4.5.0)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.9/dist-packages (from requests>=2.26.0->tiktoken==0.3.1->openai-whisper==20230314) (2022.12.7)\n",
            "Requirement already satisfied: charset-normalizer~=2.0.0 in /usr/local/lib/python3.9/dist-packages (from requests>=2.26.0->tiktoken==0.3.1->openai-whisper==20230314) (2.0.12)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.9/dist-packages (from requests>=2.26.0->tiktoken==0.3.1->openai-whisper==20230314) (3.4)\n",
            "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.9/dist-packages (from requests>=2.26.0->tiktoken==0.3.1->openai-whisper==20230314) (1.26.15)\n",
            "Building wheels for collected packages: openai-whisper, lit\n",
            "  Building wheel for openai-whisper (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for openai-whisper: filename=openai_whisper-20230314-py3-none-any.whl size=796926 sha256=bb5c1d6fa52a76488f8159a7eece64af95ff7faa563f141ed605b224935fb3b2\n",
            "  Stored in directory: /tmp/pip-ephem-wheel-cache-uge6spn4/wheels/fe/03/29/e7919208d11b4ab32972cb448bb84a9a675d92cd52c9a48341\n",
            "  Building wheel for lit (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for lit: filename=lit-16.0.0-py3-none-any.whl size=93601 sha256=b509351e3ca78341e2c91037fd87c6099bc58d772a821d7223387658a88aa883\n",
            "  Stored in directory: /root/.cache/pip/wheels/c7/ee/80/1520ca86c3557f70e5504b802072f7fc3b0e2147f376b133ed\n",
            "Successfully built openai-whisper lit\n",
            "Installing collected packages: lit, ffmpeg-python, triton, tiktoken, openai-whisper\n",
            "Successfully installed ffmpeg-python-0.2.0 lit-16.0.0 openai-whisper-20230314 tiktoken-0.3.1 triton-2.0.0\n",
            "Whisper installed，please execute next cell\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "Using device: cuda:0\n"
          ]
        }
      ],
      "source": [
        "#@markdown **配置Whisper/Setup Whisper** 🏗️\n",
        "\n",
        "!pip install requests beautifulsoup4\n",
        "! pip install git+https://github.com/openai/whisper.git\n",
        "\n",
        "import torch\n",
        "import sys\n",
        "\n",
        "device = torch.device('cuda:0')\n",
        "print('Using device:', device, file=sys.stderr)\n",
        "\n",
        "print('Whisper installed，please execute next cell')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 64
        },
        "id": "nPV9yHeqARiK",
        "outputId": "8cf507a2-a3a1-498a-aedb-f88dc3d4bc27"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████████████████████████████████| 2.87G/2.87G [00:12<00:00, 256MiB/s]\n"
          ]
        },
        {
          "data": {
            "text/markdown": [
              "**large-v2 model is selected.**"
            ],
            "text/plain": [
              "<IPython.core.display.Markdown object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "#@markdown # **Model selection** 🧠\n",
        "\n",
        "#@markdown As of the first public release, there are 4 pre-trained options to play with:\n",
        "\n",
        "#@markdown |  Size  | Parameters | English-only model | Multilingual model | Required VRAM | Relative speed |\n",
        "#@markdown |:------:|:----------:|:------------------:|:------------------:|:-------------:|:--------------:|\n",
        "#@markdown |  tiny  |    39 M    |     `tiny.en`      |       `tiny`       |     ~1 GB     |      ~32x      |\n",
        "#@markdown |  base  |    74 M    |     `base.en`      |       `base`       |     ~1 GB     |      ~16x      |\n",
        "#@markdown | small  |   244 M    |     `small.en`     |      `small`       |     ~2 GB     |      ~6x       |\n",
        "#@markdown | medium |   769 M    |    `medium.en`     |      `medium`      |     ~5 GB     |      ~2x       |\n",
        "#@markdown | large  |   1550 M   |        N/A         |      `large`       |    ~10 GB     |       1x       |\n",
        "\n",
        "#@markdown ---\n",
        "\n",
        "Model = 'large-v2' #@param ['tiny.en', 'tiny', 'base.en', 'base', 'small.en', 'small', 'medium.en', 'medium', 'large', 'large-v2']\n",
        "#@markdown ---\n",
        "#@markdown **Run this cell again if you change the model.**\n",
        "\n",
        "import whisper\n",
        "from IPython.display import Markdown\n",
        "\n",
        "whisper_model = whisper.load_model(Model)\n",
        "\n",
        "if Model in whisper.available_models():\n",
        "    display(Markdown(\n",
        "        f\"**{Model} model is selected.**\"\n",
        "    ))\n",
        "else:\n",
        "    display(Markdown(\n",
        "        f\"**{Model} model is no longer available.** Please select one of the following: - {' - '.join(whisper.available_models())}\"\n",
        "    ))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "h2AL0Hw-Bow2",
        "outputId": "9ebbfae6-308e-4da9-d4d9-6fc870de4c24"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "url https://dts-api.xiaoyuzhoufm.com/track/61358d971c5d56efe5bcb5d2/64199cbe73768bea3509176a/media.xyzcdn.net/lt5grLkHEoR-ckvLwPJVNXCfTxzr.m4a /track/61358d971c5d56efe5bcb5d2/64199cbe73768bea3509176a/media.xyzcdn.net/lt5grLkHEoR-ckvLwPJVNXCfTxzr.m4a .m4a\n",
            "Downloaded podcast episode '108.跟傅盛和王俊煜聊：大模型、产品经理和热门AI应‪用‬' to 'downloads/108.跟傅盛和王俊煜聊：大模型、产品经理和热门AI应‪用‬.m4a'\n"
          ]
        }
      ],
      "source": [
        "#@markdown # **Apple Podcast selection** 🎙️\n",
        "\n",
        "#@markdown Enter the URL of the Apple Podcast you want to transcribe.\n",
        "\n",
        "#@markdown ---\n",
        "#@markdown #### **Apple Podcast**\n",
        "URL = \"https://podcasts.apple.com/us/podcast/%E4%B9%B1%E7%BF%BB%E4%B9%A6/id1591595410?i=1000605159653\" #@param {type:\"string\"}\n",
        "#@markdown ---\n",
        "#@markdown **Run this cell again if you change the video.**\n",
        "\n",
        "import os\n",
        "import requests\n",
        "import re\n",
        "from bs4 import BeautifulSoup\n",
        "from urllib.parse import urlparse\n",
        "\n",
        "\n",
        "def find_audio_url(html: str) -> str:\n",
        "    # Find all .mp3 and .m4a URLs in the HTML content\n",
        "    audio_urls = re.findall(r'https://[^\\s^\"]+(?:\\.mp3|\\.m4a)', html)\n",
        "\n",
        "    # If there's at least one URL, return the first one\n",
        "    if audio_urls:\n",
        "        pattern = r'=https?://[^\\s^\"]+(?:\\.mp3|\\.m4a)'\n",
        "        result = re.findall(pattern, audio_urls[-1])\n",
        "        if result:\n",
        "          return result[-1][1:]\n",
        "        else:\n",
        "          return audio_urls[-1]\n",
        "\n",
        "    # Otherwise, return None\n",
        "    return None\n",
        "\n",
        "def get_file_extension(url: str) -> str:\n",
        "    # Parse the URL to get the path\n",
        "    parsed_url = urlparse(url)\n",
        "    path = parsed_url.path\n",
        "\n",
        "    # Extract the file extension using os.path.splitext\n",
        "    _, file_extension = os.path.splitext(path)\n",
        "\n",
        "    print(\"url\", url, path, file_extension)\n",
        "    # Return the file extension\n",
        "    return file_extension\n",
        "\n",
        "def download_apple_podcast(url: str, output_folder: str = 'downloads'):\n",
        "    response = requests.get(url)\n",
        "    if response.status_code != 200:\n",
        "        print(\n",
        "            f\"Error: Unable to fetch the podcast page. Status code: {response.status_code}\")\n",
        "        return\n",
        "\n",
        "    soup = BeautifulSoup(response.text, 'html.parser')\n",
        "\n",
        "    audio_url = find_audio_url(response.text)\n",
        "\n",
        "    if not audio_url:\n",
        "        print(\"Error: Unable to find the podcast audio url.\")\n",
        "        return\n",
        "\n",
        "    episode_title = soup.find('span', {'class': 'product-header__title'})\n",
        "\n",
        "    if not episode_title:\n",
        "        print(\"Error: Unable to find the podcast title.\")\n",
        "        return\n",
        "\n",
        "    episode_title = episode_title.text.strip().replace('/', '-')\n",
        "\n",
        "    if not os.path.exists(output_folder):\n",
        "        os.makedirs(output_folder)\n",
        "\n",
        "    output_file = os.path.join(output_folder, f\"{episode_title}{get_file_extension(audio_url)}\")\n",
        "\n",
        "    with requests.get(audio_url, stream=True) as r:\n",
        "        r.raise_for_status()\n",
        "        with open(output_file, 'wb') as f:\n",
        "            for chunk in r.iter_content(chunk_size=8192):\n",
        "                f.write(chunk)\n",
        "\n",
        "\n",
        "    return episode_title, output_file\n",
        "\n",
        "\n",
        "result = download_apple_podcast(URL)\n",
        "if not result:\n",
        "  print(\"Error: Unable to download podcast.\")\n",
        "else:\n",
        "  (title, filepath) = result\n",
        "  print(f\"Downloaded podcast episode '{title}' to '{filepath}'\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "lOnyZpK2EsVe",
        "outputId": "8db3e356-0768-40b9-9248-48fa7fba69ec"
      },
      "outputs": [
        {
          "data": {
            "text/markdown": [
              "### downloads/108.跟傅盛和王俊煜聊：大模型、产品经理和热门AI应‪用‬.m4a"
            ],
            "text/plain": [
              "<IPython.core.display.Markdown object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "audio local path: /content/downloads/108.跟傅盛和王俊煜聊：大模型、产品经理和热门AI应‪用‬.m4a\n",
            "[00:00.000 --> 00:07.720] 大家好 我是潘乱 欢迎来到乱盘书\n",
            "[00:07.720 --> 00:10.760] 这是一档关注商业科技和互联网的对话节目\n",
            "[00:10.760 --> 00:14.920] 这一期我们的直播主题是聊大模型和产品经理\n",
            "[00:14.920 --> 00:18.640] 两位嘉宾是移动互联网时代著名的产品经理\n",
            "[00:18.640 --> 00:22.560] 猎豹移动的创始人傅胜和豌豆莢的创始人王军玉\n",
            "[00:22.560 --> 00:26.960] 就是我们聊了包括基于大模型的一些热门产品\n",
            "[00:26.960 --> 00:30.160] 以及AI时代需要什么样的产品经理等等\n",
            "[00:30.160 --> 00:33.240] 这次直播是我跟傅胜老师第一次通过\n",
            "[00:33.240 --> 00:34.880] 就是下面口播一个广告\n",
            "[00:34.880 --> 00:38.920] 本节目由极客公务员旗下的创始人社区Fundpark发起\n",
            "[00:38.920 --> 00:41.080] 我跟张鹏老师一起主持\n",
            "[00:41.080 --> 00:43.920] 如果有AI方向的创业者想加群\n",
            "[00:43.920 --> 00:46.160] 请搜索关注Fundpark公众号\n",
            "[00:46.160 --> 00:49.720] 并回复大模型三个字就可以收到报名表单\n",
            "[00:49.720 --> 00:52.000] OK 我们直接切入正题\n",
            "[00:52.680 --> 00:56.480] 军玉最近应该是全力投入在研究GDP4\n",
            "[00:56.520 --> 01:00.960] 就是从你的视角来去看GDP4在这一波相对于3.5\n",
            "[01:00.960 --> 01:03.440] 它的变化是怎么样的\n",
            "[01:03.440 --> 01:04.800] 你的感受是怎么样的\n",
            "[01:04.800 --> 01:05.840] 是不是先说一说\n",
            "[01:06.440 --> 01:09.840] 其实我这两天一直在玩还没有特明显的感受\n",
            "[01:09.840 --> 01:10.520] 说实话\n",
            "[01:10.520 --> 01:13.600] 因为其实大家看的比较fancy的那些demo\n",
            "[01:13.600 --> 01:16.120] 我觉得OpenAI其实也取了个巧\n",
            "[01:16.120 --> 01:16.560] 对吧\n",
            "[01:16.560 --> 01:20.800] 它其实demo大家印象最深的其实是一些非常视觉的东西\n",
            "[01:20.800 --> 01:23.440] 比如说这个可以识别图像\n",
            "[01:23.440 --> 01:25.960] 可以去识别这种梗图\n",
            "[01:26.080 --> 01:30.760] 可以直接去把网站给变成非常手绘的\n",
            "[01:30.760 --> 01:34.800] 非常粗糙的一个手绘图给变成代码\n",
            "[01:35.320 --> 01:38.920] 但是这些其实在目前在线上我们能用到的版本里面\n",
            "[01:38.920 --> 01:40.880] 其实还是体验不到的\n",
            "[01:42.400 --> 01:46.760] 当然我这两天一直在测的还是说它一些比较范的一些逻辑的能力\n",
            "[01:46.760 --> 01:51.800] 比如说我们知道GDP3.5里面的一些\n",
            "[01:51.800 --> 01:55.240] 你真的要它去推理一些逻辑或者说一些比较偏数字的东西\n",
            "[01:55.280 --> 01:57.480] 它其实是很难把它很好的处理的\n",
            "[01:58.040 --> 02:00.360] 因为我脑子里面在想几个应用\n",
            "[02:00.360 --> 02:02.880] 所以一直在想说它一些逻辑的推理的能力\n",
            "[02:02.880 --> 02:04.440] 有一些推演的能力\n",
            "[02:04.440 --> 02:07.600] 有一些类比的能力在GDP4里面能不能得到一些改进\n",
            "[02:08.400 --> 02:11.120] 看起来还是有一些改进的我觉得\n",
            "[02:11.600 --> 02:13.880] 但更深的说实话我也说不出什么门道\n",
            "[02:13.880 --> 02:17.000] 因为我其实也不能算是在研究这个事情\n",
            "[02:17.000 --> 02:19.360] 我其实更像是一个爱好者\n",
            "[02:19.880 --> 02:23.360] 更像是可能07 08年开始用黑媒的人\n",
            "[02:24.200 --> 02:27.160] 对不住我自己在做手机的人\n",
            "[02:27.640 --> 02:29.320] 郭胜怎么看GDP4\n",
            "[02:29.320 --> 02:30.680] 你体验了吗\n",
            "[02:30.680 --> 02:33.880] 或者说你也可以从这个TED的GDP这里可以了解\n",
            "[02:33.880 --> 02:38.760] 就是你觉得这一波的变化你是什么感受\n",
            "[02:39.680 --> 02:43.280] GDP4因为那天晚上看它发了\n",
            "[02:43.280 --> 02:45.000] 我就忙着拍了个短视频\n",
            "[02:45.800 --> 02:48.640] 然后没想到还冲到社会榜前10名\n",
            "[02:48.640 --> 02:50.440] 然后第二天很忙\n",
            "[02:50.440 --> 02:52.040] 晚上的时候我用了一下\n",
            "[02:52.720 --> 02:54.760] 因为它的速度比较慢\n",
            "[02:54.760 --> 02:56.160] 所以我就做了一件事\n",
            "[02:56.160 --> 02:57.760] 就让他帮我写弹气蛇的游戏\n",
            "[02:57.760 --> 02:59.640] 这倒不是因为他们发布会上写\n",
            "[02:59.640 --> 03:00.800] 因为3.5的时候\n",
            "[03:01.160 --> 03:03.320] 就突然重燃了我对编程的热情\n",
            "[03:03.560 --> 03:06.240] 虽然我从来也没有对编程那么有热情\n",
            "[03:06.680 --> 03:09.240] 后来我就说我就给自己一个假设\n",
            "[03:09.240 --> 03:11.760] 我能不能够在没有任何人帮助\n",
            "[03:11.960 --> 03:14.880] 也不差于网页资料情况下去学会编程\n",
            "[03:14.880 --> 03:16.240] 或者写出一个程序来\n",
            "[03:16.680 --> 03:18.040] 所以我也step by step\n",
            "[03:18.040 --> 03:18.800] 让他一点点教我\n",
            "[03:18.800 --> 03:19.800] 就是我要写一个程序\n",
            "[03:19.800 --> 03:21.560] 我没写过了\n",
            "[03:21.560 --> 03:22.680] 让他推荐语言\n",
            "[03:22.680 --> 03:25.600] 最后我说这个执行效率不用管\n",
            "[03:25.600 --> 03:26.280] 我自己用\n",
            "[03:26.280 --> 03:27.720] 但是要特别简单的\n",
            "[03:27.720 --> 03:28.760] 那个好用的\n",
            "[03:28.760 --> 03:29.640] 可以跨平台的\n",
            "[03:29.640 --> 03:30.400] 他拍摄\n",
            "[03:30.680 --> 03:33.040] 然后装东西把环境搭建好\n",
            "[03:33.040 --> 03:33.960] 装ID\n",
            "[03:34.400 --> 03:35.280] 反而一步一步的\n",
            "[03:35.280 --> 03:36.440] 我当时装在iPad上\n",
            "[03:36.440 --> 03:37.760] 我说推荐编程环境\n",
            "[03:37.760 --> 03:39.200] 他说iPad不太适合\n",
            "[03:39.200 --> 03:39.720] 我说为什么\n",
            "[03:39.720 --> 03:40.600] 他说因为沙箱\n",
            "[03:40.840 --> 03:43.000] 但你要用还可以装哪个东西\n",
            "[03:43.440 --> 03:44.760] 对然后最好用桌面\n",
            "[03:44.760 --> 03:45.760] 我在桌面上装\n",
            "[03:45.760 --> 03:47.960] 然后又装各种库\n",
            "[03:48.560 --> 03:51.400] 但是后来在写这个探区蛇程序的时候\n",
            "[03:51.400 --> 03:53.160] 3.5给我的那个代码\n",
            "[03:53.400 --> 03:55.280] 调了半天就出错\n",
            "[03:56.000 --> 03:57.120] 后来我就贴给他\n",
            "[03:57.120 --> 03:58.400] 他就告诉我怎么怎么改\n",
            "[03:58.400 --> 03:59.160] 然后改来改去\n",
            "[03:59.160 --> 04:00.360] 反正一直没跑起来\n",
            "[04:00.920 --> 04:02.560] 对吧还有画星星程序\n",
            "[04:02.560 --> 04:03.880] 程序的时候\n",
            "[04:04.240 --> 04:05.280] 画出两个半圆\n",
            "[04:05.280 --> 04:06.640] 画的跟屁股一样对吧\n",
            "[04:06.640 --> 04:07.880] 有时候小错误很多\n",
            "[04:08.080 --> 04:09.960] 但昨天4.0我用了以后\n",
            "[04:10.280 --> 04:10.920] 他给我代码\n",
            "[04:10.920 --> 04:12.360] 我一次就跑成功了\n",
            "[04:12.960 --> 04:14.880] 就直接救探区蛇了\n",
            "[04:14.880 --> 04:16.520] 后来我也很激动拍了个视频\n",
            "[04:17.120 --> 04:18.800] 很多人说因为他就是有模板\n",
            "[04:18.800 --> 04:19.360] 其实不是的\n",
            "[04:19.880 --> 04:20.800] 他是语言模型\n",
            "[04:20.800 --> 04:22.000] 他不是搜索来的\n",
            "[04:22.200 --> 04:24.680] 他全是靠他的一步一步\n",
            "[04:24.720 --> 04:26.400] 他自己去生成的\n",
            "[04:26.920 --> 04:30.360] 所以我觉得4.0应该在逻辑能力上\n",
            "[04:30.360 --> 04:32.200] 比3.5的进步还是大的\n",
            "[04:33.000 --> 04:35.520] 刚才军宇说有点像是\n",
            "[04:35.880 --> 04:37.320] 回到易东辉网初期\n",
            "[04:38.080 --> 04:39.240] 彭总是不是又回到\n",
            "[04:39.240 --> 04:41.600] 你在索尼探门馆那时候了\n",
            "[04:42.800 --> 04:44.280] 你说的特别对\n",
            "[04:44.520 --> 04:47.000] 对因为我跟军宇基本就是在\n",
            "[04:47.000 --> 04:48.000] 那个年代认识的\n",
            "[04:48.320 --> 04:50.400] 军宇也是当年在极客公园的\n",
            "[04:50.960 --> 04:53.840] 早期的地下室舞台里面都是来过的\n",
            "[04:54.240 --> 04:57.760] 我跟军宇的感觉是有一点像的\n",
            "[04:58.000 --> 05:00.840] 他可能你说10年还稍再早一点\n",
            "[05:01.280 --> 05:03.560] 10年的时候其实已经多多少少\n",
            "[05:03.560 --> 05:04.160] 对于易东辉来讲\n",
            "[05:04.160 --> 05:05.600] 因为那时候iPhone的出现\n",
            "[05:05.880 --> 05:06.160] 对吧\n",
            "[05:06.520 --> 05:09.000] 他已经让你非常清晰的看到\n",
            "[05:09.280 --> 05:11.760] 有一个明确的通道要出现\n",
            "[05:11.760 --> 05:12.720] 然后在这里边\n",
            "[05:12.880 --> 05:13.840] 换句话说\n",
            "[05:14.120 --> 05:15.200] 如果我们谈在那个时候\n",
            "[05:15.200 --> 05:17.480] 你能看到什么叫mobile native\n",
            "[05:17.760 --> 05:19.960] 什么叫移动时代的基因\n",
            "[05:20.320 --> 05:22.640] 移动时代的应该有的这种常识\n",
            "[05:22.880 --> 05:25.000] 已经开始逐渐能够显现出来了\n",
            "[05:25.360 --> 05:27.400] 但今天我们看大模型的时候\n",
            "[05:27.880 --> 05:29.120] 还多多少少缺一点\n",
            "[05:29.120 --> 05:30.880] 就是你让我说什么叫\n",
            "[05:30.880 --> 05:32.560] generative AI的native\n",
            "[05:32.960 --> 05:34.280] 这个东西我现在还不是\n",
            "[05:34.280 --> 05:35.040] 太能说得出来\n",
            "[05:35.400 --> 05:37.920] 我刚才跟军宇说那感觉有点类似\n",
            "[05:37.920 --> 05:40.160] 但我的感觉是做产品的人\n",
            "[05:40.360 --> 05:41.560] 做创业的人的群体\n",
            "[05:41.920 --> 05:44.280] 在今天的活跃和兴奋度\n",
            "[05:44.840 --> 05:46.080] 是非常高的\n",
            "[05:46.640 --> 05:48.280] 我已经感受到了\n",
            "[05:49.240 --> 05:50.320] 其实10年的时候\n",
            "[05:50.320 --> 05:51.600] iPhone已经出了三年了\n",
            "[05:52.280 --> 05:52.560] 对\n",
            "[05:53.400 --> 05:53.840] 没错\n",
            "[05:54.960 --> 05:56.720] 但是今天GPT不也到4了吗\n",
            "[05:57.520 --> 05:59.440] 但GPT我觉得还是更加黑\n",
            "[06:00.600 --> 06:02.360] 对目前我也同意\n",
            "[06:02.520 --> 06:04.920] 就是还没有到真正的iPhone的时刻\n",
            "[06:05.360 --> 06:07.200] GPT4虽然他第一代\n",
            "[06:07.200 --> 06:08.880] 就你最多可以算是说\n",
            "[06:08.880 --> 06:10.720] 他刚刚开始接触公众\n",
            "[06:11.200 --> 06:13.320] 其实他在三代的时候\n",
            "[06:13.320 --> 06:14.960] 公众接触的还是非常有限的\n",
            "[06:15.200 --> 06:17.120] 大部分人对这个事的感知还是有限的\n",
            "[06:17.960 --> 06:20.040] 我今天本来我再补充一下\n",
            "[06:20.920 --> 06:23.600] 我替李志飞同学表达一些他的观点\n",
            "[06:23.760 --> 06:25.920] 本来今天我还要把李志飞同学\n",
            "[06:25.920 --> 06:27.400] 拉过来一起参与讨论的\n",
            "[06:27.840 --> 06:31.000] 志飞最近可能太火爆了\n",
            "[06:31.240 --> 06:33.920] 大家都知道志飞在现在大模型\n",
            "[06:34.160 --> 06:34.960] 这一波里面\n",
            "[06:35.200 --> 06:38.080] 他的时间都是被各种人约\n",
            "[06:38.600 --> 06:40.560] 我今天我看他在朋友圈\n",
            "[06:40.800 --> 06:42.400] 发了个叫李志飞的\n",
            "[06:42.400 --> 06:44.200] 我给他起名叫李八点\n",
            "[06:44.480 --> 06:45.720] 说到了GPT\n",
            "[06:45.720 --> 06:47.280] 我们把这八点说完了以后\n",
            "[06:47.280 --> 06:48.440] 也听听大家怎么看\n",
            "[06:49.000 --> 06:52.000] 首先他给了个结论说叫再度惊艳\n",
            "[06:52.320 --> 06:53.400] 觉得强过人类了\n",
            "[06:53.800 --> 06:55.560] 以前叫已经接近人类\n",
            "[06:55.560 --> 06:56.960] 但他觉得这次是强过人类了\n",
            "[06:57.200 --> 06:58.880] 刚才其实傅盛也在说\n",
            "[06:58.880 --> 07:00.840] 就是这次贪吃蛇一次成功\n",
            "[07:01.120 --> 07:03.640] 这个我觉得在之前好歹调来调去的\n",
            "[07:03.640 --> 07:04.560] 傅盛还会觉得\n",
            "[07:04.560 --> 07:05.520] 这可能还是差一点\n",
            "[07:05.520 --> 07:06.720] 但已经觉得满足了\n",
            "[07:06.960 --> 07:08.840] 但现在明显已经超过人类\n",
            "[07:09.160 --> 07:10.120] 然后说这个\n",
            "[07:10.480 --> 07:11.800] 其实有一个值得关注的点\n",
            "[07:11.800 --> 07:13.840] 就是所谓的叫科学链单\n",
            "[07:14.040 --> 07:16.440] 就是他那个叫predictable gait\n",
            "[07:16.680 --> 07:19.600] 就是他的能够预测训练结果\n",
            "[07:19.600 --> 07:22.760] 就是在你的模型的大小等等层面\n",
            "[07:22.760 --> 07:25.440] 他直接能够预测对训练结果的影响\n",
            "[07:25.760 --> 07:26.560] 这个某种程度上\n",
            "[07:26.560 --> 07:28.480] 就是从原来完全的黑匣子\n",
            "[07:28.720 --> 07:31.120] 开始有一点白盒的感觉了\n",
            "[07:31.520 --> 07:33.280] 这个是很容易被大家忽视的\n",
            "[07:33.280 --> 07:34.720] 因为我看他发布的东西\n",
            "[07:34.720 --> 07:36.400] 比大家讨论比较多的都是多模态\n",
            "[07:36.720 --> 07:39.520] 但其实这个predictable gait\n",
            "[07:39.840 --> 07:41.840] 其实也是关注他这次技术变化的\n",
            "[07:41.840 --> 07:43.160] 一个很重要的核心\n",
            "[07:43.680 --> 07:45.000] 另外他后来还列了\n",
            "[07:45.000 --> 07:46.240] 包括说重包评测\n",
            "[07:46.240 --> 07:47.080] 一举双夺\n",
            "[07:47.080 --> 07:48.760] 他OpenAI的Always\n",
            "[07:49.000 --> 07:50.920] 已经发布了引入开发者\n",
            "[07:50.920 --> 07:52.520] 爱好者的评估系统\n",
            "[07:52.720 --> 07:53.920] 其实这个事本质上\n",
            "[07:54.120 --> 07:55.840] 引入重包来去做这件事\n",
            "[07:55.840 --> 07:57.480] 我认为这件事完了以后\n",
            "[07:57.720 --> 07:58.880] 又会提他的速度\n",
            "[07:59.200 --> 08:01.040] 他除了数据飞轮还会提升\n",
            "[08:01.440 --> 08:02.880] 另外工程不漏\n",
            "[08:03.080 --> 08:05.040] 最近在里边有一些比较messy的\n",
            "[08:05.040 --> 08:06.080] 工程hack\n",
            "[08:06.080 --> 08:07.440] 他也开始做了\n",
            "[08:07.680 --> 08:09.360] 然后还有很重要的多模态\n",
            "[08:10.040 --> 08:12.120] 多模态只不过刚才俊宇好像也说\n",
            "[08:12.400 --> 08:13.720] 现在他官方也说了\n",
            "[08:13.720 --> 08:15.120] 现在还是实验阶段没放出来\n",
            "[08:15.920 --> 08:17.480] 但你如果说GPD4\n",
            "[08:17.480 --> 08:18.440] 其实最应该的\n",
            "[08:18.440 --> 08:19.800] 就比如说应该问富胜\n",
            "[08:20.120 --> 08:21.560] 你不是在干机器人吗\n",
            "[08:22.000 --> 08:22.320] 对吧\n",
            "[08:22.320 --> 08:24.200] 就是现在多模态方向\n",
            "[08:24.520 --> 08:26.800] 视频语音都可以放在一起之后\n",
            "[08:27.040 --> 08:28.320] 应该最大想象力\n",
            "[08:28.320 --> 08:30.240] 是他跟机器人的结合\n",
            "[08:31.880 --> 08:34.120] 他基本上跟万物结合了\n",
            "[08:34.400 --> 08:35.120] 你也知道\n",
            "[08:35.120 --> 08:38.000] 我们很早就做了语音视觉这些\n",
            "[08:38.000 --> 08:42.440] 但是语意它就是属于另一个种类的事情\n",
            "[08:42.920 --> 08:44.680] 所以语意一通就摆通了\n",
            "[08:44.680 --> 08:47.080] 所以他多模态对他来说\n",
            "[08:47.080 --> 08:48.360] 就非常自然的一件事\n",
            "[08:49.240 --> 08:49.480] 对吧\n",
            "[08:49.480 --> 08:52.640] 你想每幅画每个图配一些解说\n",
            "[08:52.840 --> 08:55.400] 他拿一个视觉的网络\n",
            "[08:55.400 --> 08:57.520] 然后跟这些语意连接起来\n",
            "[08:57.520 --> 09:00.200] 所以他描述图片的什么剪断了\n",
            "[09:00.400 --> 09:01.840] 他能知道这个绳子剪断能飞\n",
            "[09:01.840 --> 09:03.280] 他只要把这幅图用语言\n",
            "[09:03.280 --> 09:04.760] 把它描述出来就可以了\n",
            "[09:05.160 --> 09:08.000] 他已经具备了语言去抽象的能力的时候\n",
            "[09:08.000 --> 09:10.120] 所以他首先视觉就很容易加\n",
            "[09:10.120 --> 09:12.600] 我觉得视频没加都是因为负载问题\n",
            "[09:13.280 --> 09:15.640] 那么你再想他真的去解析视频\n",
            "[09:15.640 --> 09:17.000] 他不需要像我们看视频\n",
            "[09:17.000 --> 09:18.880] 我们看视频是一秒钟看24帧\n",
            "[09:18.880 --> 09:20.280] 是为了让我们不晕\n",
            "[09:21.400 --> 09:23.240] 他一秒钟两秒钟看一帧\n",
            "[09:23.240 --> 09:25.240] 提取每一帧就可以了\n",
            "[09:25.240 --> 09:26.640] 那天我在想他看电影\n",
            "[09:26.640 --> 09:30.160] 他不就90分钟电影看几百张图片\n",
            "[09:30.440 --> 09:33.640] 然后配上这个语音里面的文字\n",
            "[09:33.680 --> 09:36.080] 他对讲什么给你总结的一清二楚的\n",
            "[09:36.680 --> 09:39.200] 所以对的确他说那个就是机器人\n",
            "[09:39.200 --> 09:41.720] 我认为是我们终于等到了今天\n",
            "[09:41.720 --> 09:44.520] 这个以前就叫人工智障\n",
            "[09:44.520 --> 09:47.720] 就是他真是就是用户的问题千奇百怪的\n",
            "[09:47.720 --> 09:49.360] 同样一个句式那你\n",
            "[09:49.640 --> 09:51.080] 他是无穷组合的\n",
            "[09:51.080 --> 09:53.480] 所以语意的理解一直达不到实用\n",
            "[09:53.960 --> 09:55.040] 所以这一波这个\n",
            "[09:55.160 --> 09:58.160] 就是我每天都跟他有上百句的交互\n",
            "[09:58.440 --> 10:00.080] 我觉得可能有时候答案他有问题\n",
            "[10:00.080 --> 10:03.240] 但他对问题的理解本身从没有出过错\n",
            "[10:03.520 --> 10:06.160] 这是一个就是巨大的里程碑\n",
            "[10:06.160 --> 10:07.880] 就对他你表达的意思\n",
            "[10:07.880 --> 10:09.320] 他的理解是没错的\n",
            "[10:09.320 --> 10:11.720] 他最多答案你可以挑上各种错误\n",
            "[10:11.720 --> 10:13.640] 但他回答都是那一类的对吧\n",
            "[10:13.640 --> 10:15.080] 可能数学算错了\n",
            "[10:15.080 --> 10:16.240] 程序代码给错了\n",
            "[10:16.240 --> 10:18.760] 或者某一个你觉得他判断逻辑错了\n",
            "[10:18.760 --> 10:20.320] 但你讲的意思他懂\n",
            "[10:20.320 --> 10:22.560] 所以这样的话整个这个接口\n",
            "[10:23.000 --> 10:25.560] 就是整个语言语音和语义\n",
            "[10:25.560 --> 10:27.160] 完全是两个两个领域的事情\n",
            "[10:27.160 --> 10:28.920] 对是两个完全两个领域的\n",
            "[10:28.920 --> 10:30.640] 这个突破了因为机器人后面\n",
            "[10:30.760 --> 10:33.360] 可能会很快的这个这个实用化\n",
            "[10:33.360 --> 10:36.280] 就是和你用语言来交互的\n",
            "[10:37.600 --> 10:39.960] 我觉得这个复盛只说到第一层\n",
            "[10:40.240 --> 10:42.560] 我认为就现在\n",
            "[10:42.560 --> 10:44.600] 尤其在多摩钛这事加进来之后\n",
            "[10:44.960 --> 10:46.120] 比如我先说个想象\n",
            "[10:46.240 --> 10:47.920] 刚才咱们都说多摩钛这件事\n",
            "[10:47.920 --> 10:49.400] 看见那张图片之后的想象\n",
            "[10:49.760 --> 10:50.720] 我说个想象\n",
            "[10:51.120 --> 10:53.240] 现在你看我们出去玩\n",
            "[10:53.400 --> 10:55.160] 拿那个什么运动相机\n",
            "[10:55.160 --> 10:57.160] 或者什么我们拍一些这个视频\n",
            "[10:57.160 --> 10:59.080] 攀岚出去旅游拍了这个视频\n",
            "[10:59.360 --> 11:01.480] 然后拍完了都拍了20分钟\n",
            "[11:01.840 --> 11:04.200] 精彩的可能就一部分\n",
            "[11:04.200 --> 11:05.120] 你要自己剪\n",
            "[11:05.800 --> 11:07.960] 第一你还得传到这个手机\n",
            "[11:07.960 --> 11:09.800] 在本地然后再看再剪\n",
            "[11:09.800 --> 11:10.760] 然后再怎么怎么找\n",
            "[11:10.760 --> 11:12.160] 然后你要想做点效果\n",
            "[11:12.160 --> 11:13.640] 拿的各种加滤镜加效果\n",
            "[11:13.640 --> 11:15.000] 虽然这些东西都有一些了\n",
            "[11:15.240 --> 11:16.320] 但是你得自己操作\n",
            "[11:16.720 --> 11:19.240] 但我认为未来都不是说\n",
            "[11:19.240 --> 11:20.040] 你直接弄完了\n",
            "[11:20.040 --> 11:21.680] 让他就给你自己生成\n",
            "[11:21.680 --> 11:24.280] 是他先阅读你这里边的东西\n",
            "[11:24.560 --> 11:26.640] 你第一他可以跟你告诉你\n",
            "[11:26.680 --> 11:29.040] 你这个里边是有什么样的画面\n",
            "[11:29.040 --> 11:29.600] 怎么怎么着\n",
            "[11:29.600 --> 11:30.440] 他可以告诉你\n",
            "[11:30.440 --> 11:31.320] 让你自己剪\n",
            "[11:31.320 --> 11:34.480] 就你通过把这个视觉画面的信息\n",
            "[11:34.480 --> 11:35.480] 变成文字化\n",
            "[11:35.480 --> 11:36.200] 你可以剪辑\n",
            "[11:36.200 --> 11:38.280] 当然这个我觉得是一般人不会这么干的\n",
            "[11:38.400 --> 11:40.640] 就是真正专业的影像的人\n",
            "[11:40.640 --> 11:41.320] 可能这么干\n",
            "[11:41.320 --> 11:42.000] 一般的人\n",
            "[11:42.000 --> 11:44.880] 但他一个蛋能把这个信息解读成文本\n",
            "[11:45.280 --> 11:46.240] 在这个文本上\n",
            "[11:46.240 --> 11:48.360] 其实他自己就可以基于这个文本\n",
            "[11:48.360 --> 11:49.680] 再做创造\n",
            "[11:49.680 --> 11:51.640] 然后他就可以给你加效果\n",
            "[11:51.640 --> 11:53.680] 然后你还可以Program Engineering\n",
            "[11:53.680 --> 11:54.000] 对吧\n",
            "[11:54.000 --> 11:55.120] 你还可以自己嘴上说\n",
            "[11:55.240 --> 11:56.440] 我希望浪漫一点\n",
            "[11:56.440 --> 11:57.720] 我希望怎么怎么一点\n",
            "[11:57.720 --> 11:59.760] 然后你所有这些东西就都出来了\n",
            "[11:59.800 --> 12:01.320] 所以你的人生\n",
            "[12:01.320 --> 12:02.840] 你拍的所有的东西\n",
            "[12:02.920 --> 12:04.880] 因为有他的多么态的能力\n",
            "[12:04.880 --> 12:07.200] 未来他就是你旁边一个stand by的\n",
            "[12:07.480 --> 12:08.200] 摄影师\n",
            "[12:08.200 --> 12:08.920] 剪辑师\n",
            "[12:08.920 --> 12:09.560] 各种东西\n",
            "[12:09.560 --> 12:10.720] 甚至比如说无人机\n",
            "[12:10.720 --> 12:12.920] 我们现在还要自己去操作\n",
            "[12:12.920 --> 12:13.880] 你未来就说一句\n",
            "[12:13.960 --> 12:14.760] 这个景很好\n",
            "[12:14.760 --> 12:16.480] 帮我拍一个环绕的\n",
            "[12:16.480 --> 12:18.920] 他就直接识别这个环境就弄了\n",
            "[12:18.920 --> 12:19.960] 甚至你都不用说\n",
            "[12:19.960 --> 12:22.320] 他自主识别这个环境是什么信息\n",
            "[12:22.320 --> 12:24.240] 他给你用最佳的方式去拍摄\n",
            "[12:24.440 --> 12:26.760] 就是他对于哪怕对硬件领域\n",
            "[12:26.760 --> 12:27.760] 这个我说机器人\n",
            "[12:27.920 --> 12:29.400] 这个飞行的机器人无人机\n",
            "[12:29.400 --> 12:29.840] 对吧\n",
            "[12:30.120 --> 12:31.720] 这些东西的影响都很大\n",
            "[12:31.720 --> 12:33.480] 所以我觉得富胜你真正迎来的\n",
            "[12:33.480 --> 12:36.560] 都不是跟用户交互这个界面\n",
            "[12:36.560 --> 12:39.000] 是机器人自主的判断\n",
            "[12:39.000 --> 12:40.480] 自己眼里有活\n",
            "[12:40.480 --> 12:42.720] 这件事都会因此有巨大的进步\n",
            "[12:42.720 --> 12:44.480] 就是这个上半身进步了\n",
            "[12:44.480 --> 12:45.880] 你们原来搞下半身的\n",
            "[12:46.120 --> 12:48.280] 我听你们的机器人搞下半身\n",
            "[12:48.280 --> 12:51.200] 搞这个现在上半身可以了\n",
            "[12:51.640 --> 12:53.000] 不准讲禁用词\n",
            "[12:53.040 --> 12:53.560] 这个\n",
            "[12:54.200 --> 12:56.120] 对主要是判断问我那个问题\n",
            "[12:56.120 --> 12:58.720] 我也是把这个东西抽象成两层\n",
            "[12:58.720 --> 13:02.280] 第一层就是他的交互的界面会发生\n",
            "[13:02.280 --> 13:02.840] 变革\n",
            "[13:02.840 --> 13:05.600] 第二个就是整个决策的能力\n",
            "[13:05.600 --> 13:08.000] 就是他他上就是一个交互能力\n",
            "[13:08.000 --> 13:08.960] 一个就是决策力\n",
            "[13:08.960 --> 13:11.000] 他的决策力就已经开始\n",
            "[13:11.280 --> 13:14.040] 可以再把整个社会生产力给提升了\n",
            "[13:14.440 --> 13:16.400] 这个就是冲击到每一个\n",
            "[13:16.400 --> 13:18.480] 就是初阶的脑力功能\n",
            "[13:19.280 --> 13:21.800] 基本上都可替代\n",
            "[13:22.160 --> 13:24.520] 我也是感受\n",
            "[13:26.160 --> 13:28.840] 但如果顺着刚才彭总想象那个方向去聊\n",
            "[13:29.280 --> 13:30.360] 他一方面有个注册\n",
            "[13:30.440 --> 13:32.200] 其实你要现在苹果的相册\n",
            "[13:32.200 --> 13:33.560] 就帮你干类似的事情\n",
            "[13:33.920 --> 13:37.480] 然后已经不知道这对内容平台是好是坏\n",
            "[13:37.680 --> 13:40.200] 相当于是以后大家内容创作的水平\n",
            "[13:40.200 --> 13:41.560] 都会无限的提升\n",
            "[13:41.560 --> 13:41.880] 对吧\n",
            "[13:41.880 --> 13:42.880] 现在我们刷个\n",
            "[13:42.880 --> 13:44.120] 我现在看到一张照片\n",
            "[13:44.120 --> 13:44.840] 我都会想\n",
            "[13:45.320 --> 13:46.480] 这是不是AI生成的\n",
            "[13:46.600 --> 13:48.040] 就比如看到一个美女照片\n",
            "[13:48.040 --> 13:50.640] 然后或者说我们在下面\n",
            "[13:50.760 --> 13:51.560] 如果它是修图的\n",
            "[13:51.560 --> 13:53.600] 我们就加一句很有科技感\n",
            "[13:53.920 --> 13:55.000] AI含量比较高\n",
            "[13:55.000 --> 13:55.640] 类似这种\n",
            "[13:55.640 --> 13:57.200] 但我想到其实另外一个事情\n",
            "[13:57.840 --> 14:01.560] 虽然一方面大家是创作内容的能力\n",
            "[14:01.560 --> 14:02.360] 被无限增强\n",
            "[14:02.360 --> 14:03.200] 但其实是一个\n",
            "[14:03.200 --> 14:05.320] 大家其实如果真正懂你的那个人\n",
            "[14:05.720 --> 14:07.920] 我觉得特别利好微信\n",
            "[14:07.920 --> 14:09.800] 因为每个人都在微信里面囤了\n",
            "[14:09.800 --> 14:12.240] 就是大家的最主动的表达\n",
            "[14:12.240 --> 14:13.520] 最大量的主动表达\n",
            "[14:13.520 --> 14:14.680] 其实都在微信里面\n",
            "[14:14.880 --> 14:16.720] 所以我觉得以后大家就不要吐槽\n",
            "[14:17.080 --> 14:19.480] 微信占你手机里面绝大部分内存了\n",
            "[14:19.640 --> 14:23.240] 你以后链单就得靠把你微信数据导进去\n",
            "[14:23.920 --> 14:26.360] 你其他浏览内容的数据不行\n",
            "[14:26.360 --> 14:27.640] 得靠你自己主动的\n",
            "[14:27.640 --> 14:29.560] 跟人交互的那些数据更有用\n",
            "[14:30.840 --> 14:34.040] 俊宇你觉得今天看到这个能力之后\n",
            "[14:34.560 --> 14:37.640] 个人的数据跟GPT-4\n",
            "[14:37.640 --> 14:39.920] 未来在做紧密的结合\n",
            "[14:40.160 --> 14:43.040] 是不是他对于个人的这种\n",
            "[14:43.040 --> 14:44.760] 所谓的助理的能力\n",
            "[14:45.080 --> 14:47.200] 或者是对个人的这种加持\n",
            "[14:47.560 --> 14:49.360] 会是一个很重要的维度\n",
            "[14:49.480 --> 14:50.200] 我不知道你怎么看\n",
            "[14:50.360 --> 14:52.120] 就是这种运用大模型\n",
            "[14:52.120 --> 14:55.320] 但是针对这个大模型还要更熟悉我\n",
            "[14:55.560 --> 14:57.440] 然后我可以给他很多数据这件事\n",
            "[14:57.440 --> 14:59.200] 这个里面有什么样的思考吗\n",
            "[15:00.000 --> 15:02.280] 我这个思考的逻辑有点复杂\n",
            "[15:02.280 --> 15:03.840] 首先其实说个人逻辑\n",
            "[15:04.080 --> 15:04.920] 个人助理这个事\n",
            "[15:04.920 --> 15:07.960] 其实可能大家都想了很多很多很多很多点\n",
            "[15:08.400 --> 15:11.720] 我们原来在豌豆夹也曾经想做这个事情\n",
            "[15:11.720 --> 15:13.480] 但我们还是一个很小的友团队\n",
            "[15:13.840 --> 15:16.200] 最后肯定也没有把它给做成\n",
            "[15:16.400 --> 15:19.680] 他当时的感受和现在的很现实的感受\n",
            "[15:19.680 --> 15:23.680] 最大的瓶颈都可能不是个人智能助理里面的\n",
            "[15:23.680 --> 15:25.240] 所谓的智能的这一部分\n",
            "[15:25.880 --> 15:27.960] 而是数据的输入和输出这一部分\n",
            "[15:28.280 --> 15:30.680] 其实大概在我今天突然想起来\n",
            "[15:30.680 --> 15:32.280] 在大概2010年左右\n",
            "[15:32.400 --> 15:35.720] 有一个跟jobbox差不多同时出现的产品\n",
            "[15:35.720 --> 15:36.440] 叫Grappling\n",
            "[15:36.920 --> 15:39.400] 对就是Grappling\n",
            "[15:39.840 --> 15:40.960] 这个产品其实特别简单\n",
            "[15:41.440 --> 15:42.320] 也不能说很简单\n",
            "[15:42.720 --> 15:44.480] 就他其实要做的事情很简单\n",
            "[15:44.760 --> 15:45.760] 你登录进去\n",
            "[15:45.760 --> 15:47.960] 你可以绑定你的各种各样的云服务\n",
            "[15:48.600 --> 15:49.440] 比如说jobbox\n",
            "[15:49.440 --> 15:50.320] Google drive\n",
            "[15:50.320 --> 15:51.360] space cam\n",
            "[15:51.800 --> 15:52.600] Google calendar\n",
            "[15:52.600 --> 15:53.640] 你能想到所有的云服务\n",
            "[15:53.640 --> 15:54.640] 你都可以绑上去\n",
            "[15:55.160 --> 15:57.920] 然后他进去去索引你的所有的个人数据\n",
            "[15:58.400 --> 16:00.400] 然后他去做一个搜索\n",
            "[16:01.040 --> 16:03.080] 其实这个服务是很有用的\n",
            "[16:03.080 --> 16:03.640] 对我来讲\n",
            "[16:03.640 --> 16:06.680] 尤其是说我们这种所谓的cloud native\n",
            "[16:07.120 --> 16:10.240] 就是大部分的数据都在云上面的人来讲\n",
            "[16:11.000 --> 16:11.520] 回到今天\n",
            "[16:11.520 --> 16:13.480] 其实我今天下午查我的密码\n",
            "[16:13.480 --> 16:15.080] 我就忘了我是放在one password\n",
            "[16:15.080 --> 16:15.800] 还是放在\n",
            "[16:16.280 --> 16:16.800] chrome里面\n",
            "[16:16.800 --> 16:19.200] 还是放在iCloud的keychain里面\n",
            "[16:19.200 --> 16:20.360] 三个地方都找了一遍\n",
            "[16:20.880 --> 16:22.480] 其实你每次这个时候我就会想说\n",
            "[16:22.560 --> 16:23.600] 但要是有一个服务\n",
            "[16:24.000 --> 16:25.360] 就把这三者都打通\n",
            "[16:25.880 --> 16:26.440] 那就很好\n",
            "[16:27.040 --> 16:28.440] 但的确它的阻力也会很大\n",
            "[16:28.440 --> 16:28.720] 对吧\n",
            "[16:28.720 --> 16:30.520] 第一你会很容易想到有privacy\n",
            "[16:30.520 --> 16:31.920] 有隐私的担心\n",
            "[16:32.680 --> 16:35.480] 第二我猜想对于绝大多数用户来讲\n",
            "[16:36.200 --> 16:39.040] 这上面要付出的额外的准备的成本\n",
            "[16:39.680 --> 16:41.600] 是没有它带来的便利\n",
            "[16:42.240 --> 16:44.000] 就这两者相比来讲的话\n",
            "[16:44.000 --> 16:46.160] 大家是不太愿意说付出这么大的成本\n",
            "[16:46.520 --> 16:49.760] 去获得可能并不是每天无时无刻\n",
            "[16:49.760 --> 16:51.640] 都能感受到的这种便利\n",
            "[16:52.240 --> 16:55.200] 所以大家也大概率的不会去做这个事情\n",
            "[16:55.680 --> 16:57.000] 比如说今天来讲的话\n",
            "[16:57.000 --> 16:58.760] Siri或者说Google Assistant\n",
            "[16:58.760 --> 16:59.440] 如果你愿意的话\n",
            "[16:59.440 --> 17:01.520] 你其实可以让它记住很多信息\n",
            "[17:02.280 --> 17:04.200] 它有一些口令是可以让它记住一些信息的\n",
            "[17:05.240 --> 17:07.960] 包括是说我们现在市面上能用到的一些\n",
            "[17:08.320 --> 17:09.360] 别的一些个人助理\n",
            "[17:09.640 --> 17:11.400] 哪怕是说像grow这种\n",
            "[17:11.680 --> 17:13.400] 偏娱乐化的一些AI的聊天\n",
            "[17:13.400 --> 17:14.640] 其实你也给它记住信息\n",
            "[17:14.960 --> 17:17.600] 对但是其实大多数人可能对它来讲\n",
            "[17:17.600 --> 17:20.160] 它的这样的一个交互的ROI\n",
            "[17:20.600 --> 17:21.960] 就是这样的一个投资回报\n",
            "[17:22.480 --> 17:23.360] 可能还是太低\n",
            "[17:24.080 --> 17:25.040] 这是比较悲观的想法\n",
            "[17:25.600 --> 17:26.520] 比较乐观的想法\n",
            "[17:26.680 --> 17:29.680] 就是会在想说我们今天有AGI的出现\n",
            "[17:30.040 --> 17:32.000] 有这种通用的人工智能的出现\n",
            "[17:32.320 --> 17:34.720] 它会不会让它的回报变得足够的高\n",
            "[17:34.720 --> 17:36.520] 以至于大家愿意花费一些额外的成本\n",
            "[17:36.520 --> 17:37.200] 去做这个事情\n",
            "[17:37.920 --> 17:39.920] 哪怕今天我们的整个的生态环境\n",
            "[17:40.280 --> 17:41.520] 没有太大的变化\n",
            "[17:42.080 --> 17:43.840] 比如说像前阵子\n",
            "[17:44.360 --> 17:45.960] 美国有一个也是产品\n",
            "[17:45.960 --> 17:47.800] 黄重本会去用的一个产品叫rewind\n",
            "[17:48.720 --> 17:51.480] 这个产品其实给人讲的话会有点吓人\n",
            "[17:51.960 --> 17:53.440] 初听起来会有点吓人\n",
            "[17:53.880 --> 17:55.400] 它相当于就是在你的Mac上面\n",
            "[17:55.400 --> 17:56.560] 去装一个录屏软件\n",
            "[17:57.120 --> 17:59.640] 把你的Mac的7×24小时都给录下来\n",
            "[18:00.160 --> 18:03.280] 然后它去做这上面的文字的OCR的识别\n",
            "[18:04.120 --> 18:06.080] 这样子只要你在电脑上见过的东西\n",
            "[18:06.080 --> 18:07.480] 它都可以帮你去搜索出来\n",
            "[18:07.920 --> 18:09.600] 对我相信在听的\n",
            "[18:09.600 --> 18:11.400] 即使大多数人可能是做产品的\n",
            "[18:11.720 --> 18:13.440] 也会觉得这个想法有点吓人\n",
            "[18:13.880 --> 18:14.160] 对吧\n",
            "[18:14.160 --> 18:15.800] 即使他承诺是说\n",
            "[18:15.800 --> 18:17.720] 他的这个数据只保存在本地\n",
            "[18:18.080 --> 18:19.240] 永远不会上传到云端\n",
            "[18:19.240 --> 18:20.320] 你还是会觉得有点吓人\n",
            "[18:21.520 --> 18:23.520] 说实话他今天的工程上面的实现\n",
            "[18:24.200 --> 18:26.240] 我用了也觉得用处不是特别的大\n",
            "[18:26.800 --> 18:29.160] 何况我们今天其实今天大部分的时间\n",
            "[18:29.160 --> 18:30.760] 其实并不是在电脑上面\n",
            "[18:31.160 --> 18:32.320] 是在手机上面\n",
            "[18:33.520 --> 18:34.600] 手机上面能不能做这个事情\n",
            "[18:34.720 --> 18:35.440] 也许可以对吧\n",
            "[18:35.440 --> 18:36.720] 我们今天在微信里面\n",
            "[18:36.720 --> 18:38.600] 翻过很多转瞬即逝的消息\n",
            "[18:38.600 --> 18:39.600] 会说总是想不起来\n",
            "[18:39.600 --> 18:40.800] 到底在哪个聊天里面\n",
            "[18:41.160 --> 18:42.200] 有人告诉我个什么事\n",
            "[18:42.520 --> 18:44.240] 是今晚到底是8点还是8点半\n",
            "[18:44.240 --> 18:44.600] 对吧\n",
            "[18:45.440 --> 18:46.600] 对像这样的一些事情\n",
            "[18:46.600 --> 18:49.280] 如果是说它能够到了某样的一个基点\n",
            "[18:49.280 --> 18:50.560] 到了某样的一个预值\n",
            "[18:50.840 --> 18:52.520] 那它变得对用户足够的有用\n",
            "[18:52.520 --> 18:53.640] 也许大家会愿意是说\n",
            "[18:53.640 --> 18:55.880] 把这个工作的数据去交给他\n",
            "[18:56.760 --> 18:59.040] 但这些都是在整个生态链不变的情况下\n",
            "[18:59.040 --> 19:01.120] 如果是说生态链有些变化\n",
            "[19:01.120 --> 19:02.640] 比如说微信的数据能直接拿到\n",
            "[19:03.160 --> 19:05.000] 那当然这个会有很大的一些变化\n",
            "[19:05.000 --> 19:07.000] 但这个就可能过于可怕了一点\n",
            "[19:07.000 --> 19:08.440] 我们今天会去想象这个事情\n",
            "[19:09.440 --> 19:13.120] 不如在眼睛上面装一个24小时摄像头\n",
            "[19:13.120 --> 19:16.880] 比如说开发一个眼镜可以无限续航的\n",
            "[19:16.880 --> 19:17.880] 那回到这儿\n",
            "[19:17.880 --> 19:20.200] 我觉得也就是我在想象\n",
            "[19:20.360 --> 19:22.200] 就未来的这个个人助理\n",
            "[19:22.960 --> 19:25.560] 如果真的就它会带来很大改变的\n",
            "[19:25.560 --> 19:27.360] 比如说如果真的微信\n",
            "[19:27.720 --> 19:31.040] 基于微信上面能长出一个很强的个人助理\n",
            "[19:32.040 --> 19:33.120] 天天富胜怎么看\n",
            "[19:33.240 --> 19:35.280] 刚才我们伟大的设想\n",
            "[19:36.000 --> 19:40.320] 要是万一我们在微信上能够训练出非常强的个人助理\n",
            "[19:40.320 --> 19:42.680] 刚才有人说个人助理没有工作助理有用\n",
            "[19:42.680 --> 19:45.520] 你在微信上就起码有至少一半在工作\n",
            "[19:45.520 --> 19:47.800] 不要装了你肯定不是只是在生活\n",
            "[19:47.800 --> 19:50.000] 所以这个富胜怎么看\n",
            "[19:50.000 --> 19:53.040] 有没有可能就是真的有这么很强大的个人助理\n",
            "[19:53.040 --> 19:55.120] 结果成为了一个超强的操作系统\n",
            "[19:55.120 --> 19:57.320] 带来了整个生态的改变\n",
            "[19:58.160 --> 19:59.720] 几乎是必然吧\n",
            "[19:59.720 --> 20:00.880] 长期来说\n",
            "[20:01.160 --> 20:02.880] 我觉得长期肯定会\n",
            "[20:03.560 --> 20:05.360] 但是是微信做\n",
            "[20:05.360 --> 20:09.720] 还如果讲的严重点也可能会是颠覆微信的机会了\n",
            "[20:11.280 --> 20:14.480] 你想每一代的形式的变化\n",
            "[20:14.480 --> 20:15.520] 从移动\n",
            "[20:15.800 --> 20:17.720] 就当然麻烦他们说如果微信不退出\n",
            "[20:17.720 --> 20:18.840] 通讯就危险了对吧\n",
            "[20:19.080 --> 20:21.640] 如果Facebook不收过WhatsApp也那个了\n",
            "[20:22.200 --> 20:23.360] 这还是看动作吧\n",
            "[20:23.880 --> 20:26.040] 我觉得个人助理这件事是肯定的\n",
            "[20:26.040 --> 20:26.760] 大家都盯着的\n",
            "[20:26.760 --> 20:27.880] 因为这种最容易想到了\n",
            "[20:27.880 --> 20:29.880] 而且非常能做到的\n",
            "[20:30.880 --> 20:33.240] 其实我就觉得\n",
            "[20:33.240 --> 20:36.680] 其实我自己在写的程序叫助理2.0\n",
            "[20:36.680 --> 20:40.520] 我准备写一个就我自己说的话\n",
            "[20:40.520 --> 20:41.920] 还会给我把日地排好\n",
            "[20:42.480 --> 20:44.640] 这件事其实基本的做了\n",
            "[20:45.240 --> 20:47.840] 对如果在多模态大模型里面\n",
            "[20:47.840 --> 20:50.960] 它更多是其实是已经是偏向自然语言了\n",
            "[20:51.120 --> 20:54.600] 不需要我们就是输入文字来去跟他交互的话\n",
            "[20:54.600 --> 20:58.640] 那是否以后手机它其实不是最好载体\n",
            "[20:58.960 --> 21:01.760] 我理解比如说眼镜或者说其他的手表手环\n",
            "[21:01.760 --> 21:05.000] 这种可穿戴的有可能才是更加载体\n",
            "[21:05.920 --> 21:09.360] 对就电影赫里就差不多\n",
            "[21:09.360 --> 21:11.600] 就是赫里里面的那套交互逻辑\n",
            "[21:11.600 --> 21:13.600] 对影音上手2049里面的\n",
            "[21:13.600 --> 21:14.880] 就是直接全息投影了\n",
            "[21:14.880 --> 21:16.440] 就是看哪里没屏幕\n",
            "[21:16.440 --> 21:18.400] 何必要盯着一个手机呢\n",
            "[21:20.040 --> 21:22.200] 那假设有一个替代人的\n",
            "[21:22.480 --> 21:24.680] 对于人类某种感官是一个补充\n",
            "[21:24.960 --> 21:27.440] 还有相对来讲没有那么侵害隐私\n",
            "[21:27.960 --> 21:29.840] 也许我觉得这种产品的形态是存在的\n",
            "[21:29.840 --> 21:32.920] 但总体上来讲又回到悲观的这一面\n",
            "[21:33.040 --> 21:36.240] 我觉得大多数人可能又没有那么在意效率等等的\n",
            "[21:36.240 --> 21:36.720] 对吧\n",
            "[21:36.720 --> 21:39.640] 包括是说我们原来做公司做了很多年以后\n",
            "[21:39.640 --> 21:40.720] 我一直很惊讶\n",
            "[21:40.720 --> 21:44.000] 就是说为什么大多数人其实不想不用日历\n",
            "[21:44.440 --> 21:45.960] 大多数人是不用日历的\n",
            "[21:46.440 --> 21:47.960] 对于大多数人没有忙到这种程度\n",
            "[21:47.960 --> 21:49.360] 我到这一两年可能才感受到\n",
            "[21:49.360 --> 21:50.760] 因为这一两年我也很闲\n",
            "[21:51.160 --> 21:52.440] 我也不用日历了\n",
            "[21:53.040 --> 21:54.680] 你很快就开始要用了\n",
            "[21:54.680 --> 21:56.000] 对你又该要用了\n",
            "[21:56.640 --> 21:58.640] 对我们原来说为什么大家不用日历\n",
            "[21:58.640 --> 22:01.880] 你看我们当时我写的脚本\n",
            "[22:01.880 --> 22:04.200] 跑了一下公司里面的日历的使用量\n",
            "[22:04.320 --> 22:06.840] 的确对于大部分的人来讲\n",
            "[22:06.840 --> 22:08.520] 他的工作相对来讲比较单一\n",
            "[22:08.520 --> 22:10.840] 他也没有什么要跟人接触去coordinate\n",
            "[22:11.160 --> 22:12.320] 去协调的一些时间\n",
            "[22:12.320 --> 22:13.480] 但其实没有那么忙\n",
            "[22:13.840 --> 22:16.800] 所以我们当然是说我们做互联网做产品\n",
            "[22:16.800 --> 22:18.920] 包括我自己可能往下做\n",
            "[22:18.920 --> 22:22.960] 也还是会想做一些跟效率等等有关系的一些东西\n",
            "[22:22.960 --> 22:23.880] 但我今天还在想说\n",
            "[22:23.880 --> 22:26.760] 其实你看移动互联网上面最多的应用\n",
            "[22:26.760 --> 22:28.320] 其实最后不是效率性的\n",
            "[22:28.600 --> 22:30.680] 它其实是帮你更好的去娱乐\n",
            "[22:30.680 --> 22:32.720] 帮你更好的去enjoy yourself\n",
            "[22:32.720 --> 22:34.720] 你也可以说是就更好的享受生活\n",
            "[22:34.920 --> 22:36.800] 所以这可能也是我们去想这个问题\n",
            "[22:36.800 --> 22:37.920] 容易有的一个局限\n",
            "[22:39.040 --> 22:41.040] 所以最好的创业者\n",
            "[22:41.040 --> 22:46.640] 不断的追求对自己用最极致效率的工具\n",
            "[22:46.640 --> 22:49.680] 然后给大家创造最不需要效率的产品\n",
            "[22:49.840 --> 22:50.520] 然后对吧\n",
            "[22:50.840 --> 22:52.040] 这才是最美的\n",
            "[22:52.040 --> 22:55.280] 最能popular的产品和创业者\n",
            "[22:55.480 --> 22:56.440] 就基本是这个感觉\n",
            "[22:56.440 --> 22:57.720] 来傅胜还没说说\n",
            "[22:57.840 --> 23:00.160] 你觉得手机这件事\n",
            "[23:00.640 --> 23:04.440] 它的形态和它的产业的未来的发展\n",
            "[23:04.440 --> 23:08.040] 会因为大模型这件事有什么分岔点吗\n",
            "[23:08.040 --> 23:09.880] 我们今天比较开脑洞的想一想\n",
            "[23:11.080 --> 23:12.400] 接到这句刚刚讲的话\n",
            "[23:12.400 --> 23:13.520] 这个具体的问题\n",
            "[23:13.520 --> 23:14.600] 我觉得具体还有一个问题\n",
            "[23:14.600 --> 23:15.960] 就是它使用太复杂了\n",
            "[23:16.640 --> 23:18.640] 你为它的使用成本太高\n",
            "[23:19.000 --> 23:20.320] 然后收益又不大\n",
            "[23:20.320 --> 23:21.680] 就很多人不是太忙\n",
            "[23:21.880 --> 23:24.360] 所以基本上脑子或者拿个计时本就记一下\n",
            "[23:24.360 --> 23:26.000] 你想用日历记个操作步骤\n",
            "[23:26.000 --> 23:27.080] 第一个打开日历\n",
            "[23:27.080 --> 23:28.040] 第二选择一天\n",
            "[23:28.040 --> 23:29.240] 还要再选小时\n",
            "[23:29.240 --> 23:31.520] 还要是前两步就反了\n",
            "[23:31.520 --> 23:32.200] 你知道吧\n",
            "[23:32.400 --> 23:36.280] 其实真正最用日历的一些高端人士\n",
            "[23:36.280 --> 23:37.760] 都是让助理去用日历\n",
            "[23:38.120 --> 23:38.440] 对吧\n",
            "[23:38.440 --> 23:40.160] 他就是等十天就好了\n",
            "[23:40.280 --> 23:41.800] 所以它的使用成本太高\n",
            "[23:41.800 --> 23:44.640] 但这是在图形化界面下无法避免的\n",
            "[23:45.240 --> 23:46.280] 所以这是一个点\n",
            "[23:46.320 --> 23:47.200] 当然我也同意\n",
            "[23:47.360 --> 23:49.600] 就效率型的不是最大的市场\n",
            "[23:49.640 --> 23:51.880] 因为太多人不够那个\n",
            "[23:52.280 --> 23:55.600] 然后我觉得手机的这个分叉\n",
            "[23:56.080 --> 23:57.440] 肯定是到了\n",
            "[23:57.440 --> 24:00.400] 就是本质上就交互改变嘛\n",
            "[24:00.400 --> 24:03.200] 交互从图形变语音的话\n",
            "[24:03.200 --> 24:04.360] 就是一次巨大的改变\n",
            "[24:04.360 --> 24:05.440] 但我想说一点\n",
            "[24:05.440 --> 24:08.440] 就这一次的发动不是从端上开始\n",
            "[24:08.440 --> 24:10.160] 是从语音上可能\n",
            "[24:10.360 --> 24:12.400] 就大模型这件事啊\n",
            "[24:14.160 --> 24:15.160] 因为是\n",
            "[24:15.680 --> 24:16.360] 就是你想\n",
            "[24:16.360 --> 24:18.240] iPhone刚发布的时候是没有iCloud\n",
            "[24:18.720 --> 24:19.080] 对吧\n",
            "[24:19.080 --> 24:20.240] 他只是这个设计好\n",
            "[24:20.240 --> 24:20.960] 这个design好\n",
            "[24:20.960 --> 24:21.520] 这个形式好\n",
            "[24:21.520 --> 24:22.480] 大家就开始用起来了\n",
            "[24:22.560 --> 24:23.560] 然后大家开始同质化\n",
            "[24:23.560 --> 24:25.400] 所以这时候你是能抢微博市场的\n",
            "[24:25.480 --> 24:27.960] 但如果以后真的因为这件事\n",
            "[24:27.960 --> 24:29.760] 产生了手机的重大变革\n",
            "[24:30.160 --> 24:32.360] 那么谁有大的那个端\n",
            "[24:32.640 --> 24:33.080] 你你你你\n",
            "[24:33.080 --> 24:34.640] 你没想过微软哪天推个手机\n",
            "[24:34.640 --> 24:35.480] 就会很火\n",
            "[24:36.200 --> 24:37.640] 或者是一个这样的设备\n",
            "[24:37.640 --> 24:39.000] 因为他的逻辑变了\n",
            "[24:39.120 --> 24:40.280] 所以这是一个\n",
            "[24:40.560 --> 24:43.320] 其实如果手机厂商应该去考虑的点了\n",
            "[24:43.320 --> 24:44.760] 就这个时间拐点\n",
            "[24:45.320 --> 24:47.080] 对端的依赖会极度下降\n",
            "[24:47.520 --> 24:48.760] 可能玩游戏还需要\n",
            "[24:48.760 --> 24:50.240] 就大部分人看个东西啊\n",
            "[24:50.240 --> 24:50.920] 记个事啊\n",
            "[24:50.920 --> 24:53.560] 他他他不再需要这个屏幕的那种\n",
            "[24:53.640 --> 24:54.400] 灵敏度了\n",
            "[24:54.400 --> 24:54.640] 对吧\n",
            "[24:54.640 --> 24:56.040] 就说句话就解决了\n",
            "[24:56.280 --> 24:57.840] 所以我我我觉得可能这个产业\n",
            "[24:57.840 --> 24:59.080] 可能会发生重大变革\n",
            "[24:59.480 --> 25:00.200] 我的感受啊\n",
            "[25:00.320 --> 25:00.720] 嗯\n",
            "[25:00.960 --> 25:03.640] 对我觉得我比较同意富盛的这个观点啊\n",
            "[25:03.640 --> 25:05.200] 其实我甚至大胆的\n",
            "[25:05.480 --> 25:06.920] 就也许未必完\n",
            "[25:07.080 --> 25:09.480] 完全准确啊或者是完整\n",
            "[25:09.560 --> 25:12.920] 但我我的一个直觉就是端的重要性在\n",
            "[25:13.240 --> 25:14.000] 往后退\n",
            "[25:14.320 --> 25:16.680] 云的重要性在往前往前提\n",
            "[25:16.960 --> 25:18.800] 有某种程度上就刚才我举的例子\n",
            "[25:18.800 --> 25:20.400] 就是我拍的很多东西\n",
            "[25:20.560 --> 25:21.840] 我如果存在了\n",
            "[25:22.000 --> 25:23.760] 那个设备拍完了就上云\n",
            "[25:24.000 --> 25:27.160] 我未来就在那里面去调动我的人生故事\n",
            "[25:27.320 --> 25:28.880] 那那个云才是最重要的\n",
            "[25:28.880 --> 25:30.240] 那个端不是最重要\n",
            "[25:30.360 --> 25:32.640] 对吧如果有一个很强的AI助理\n",
            "[25:33.120 --> 25:35.080] 云里面对我的理解是重要的\n",
            "[25:35.080 --> 25:36.640] 那个端不是最重要的\n",
            "[25:36.640 --> 25:37.840] 他就是麦克风对吧\n",
            "[25:37.840 --> 25:39.680] 就是他发出声音的东西\n",
            "[25:39.960 --> 25:43.160] 所以这个的改变今天还不会那么明显\n",
            "[25:43.160 --> 25:45.680] 但长期来看你想起来会不会发毛的\n",
            "[25:45.840 --> 25:47.320] 这个是一个根本性\n",
            "[25:47.840 --> 25:50.320] 所以你就说微软为什么对这事情这么上心\n",
            "[25:50.640 --> 25:52.440] 微软就是到最后都是用他的云\n",
            "[25:53.400 --> 25:54.200] 对啊\n",
            "[25:54.360 --> 25:55.400] 当年就是这样\n",
            "[25:55.760 --> 25:57.080] iPhone实现了一部分\n",
            "[25:57.080 --> 25:58.640] 就是说他用网络相册\n",
            "[25:58.840 --> 26:01.880] 把你给套牢了一大部分\n",
            "[26:01.880 --> 26:03.920] 就今天我要换个安卓\n",
            "[26:03.920 --> 26:06.600] 我这个两边相册就搞死了对吧\n",
            "[26:06.800 --> 26:09.720] 而且我现在云端的网络相册\n",
            "[26:09.720 --> 26:11.320] 已经就是他最大的1TB\n",
            "[26:11.320 --> 26:13.320] 我家庭共享都已经没空间了\n",
            "[26:13.720 --> 26:15.400] 我是希望他出2TB版\n",
            "[26:15.440 --> 26:17.400] 他是靠这个锁定了一部分\n",
            "[26:17.400 --> 26:20.640] 但是变成了这种大数据模型的这种\n",
            "[26:20.920 --> 26:22.440] 对你的个性的分析以后\n",
            "[26:22.440 --> 26:23.840] 这个就牢不可破了\n",
            "[26:24.640 --> 26:25.680] 对我说到这\n",
            "[26:25.680 --> 26:28.360] 我觉得正好刚才有很多人都提到隐私问题\n",
            "[26:28.360 --> 26:29.840] 包括潘乱也提到\n",
            "[26:30.040 --> 26:31.520] 孙玉其实也提到一些这种\n",
            "[26:31.520 --> 26:33.520] 就我觉得这我也有一个推论\n",
            "[26:33.600 --> 26:35.040] 不知道对不对大家讨论\n",
            "[26:35.240 --> 26:38.160] 正是因为如果你看我的直播间也说云重要了\n",
            "[26:38.160 --> 26:39.400] 但就涉及隐私问题了\n",
            "[26:39.600 --> 26:40.880] 所以我们要做好准备\n",
            "[26:40.880 --> 26:44.200] 就是如果你想通过这种云端的AI\n",
            "[26:44.320 --> 26:46.480] 提升自己的能力\n",
            "[26:46.480 --> 26:49.960] 或者说你生活的质量和更幸福的体验\n",
            "[26:50.160 --> 26:53.840] 你要做好要多往云上真正花钱的准备\n",
            "[26:54.000 --> 26:55.880] 因为这里存在一个一个悖论\n",
            "[26:56.000 --> 26:57.560] 就是你想用免费的\n",
            "[26:57.560 --> 27:01.080] 这个免费的一定是通过某种方式转换价值的\n",
            "[27:01.640 --> 27:03.360] 你想象如果我的助理\n",
            "[27:03.600 --> 27:05.040] 他是免费给我的\n",
            "[27:05.120 --> 27:06.720] 他了解我一切的数据\n",
            "[27:06.800 --> 27:08.720] 但他是别人派来的\n",
            "[27:08.800 --> 27:11.400] 然后别人是要通过他赚钱的\n",
            "[27:11.440 --> 27:13.120] 就最终我总要出钱\n",
            "[27:13.200 --> 27:14.560] 要不他怎么养活那个公司\n",
            "[27:15.160 --> 27:16.480] 你就会造成一个问题\n",
            "[27:16.480 --> 27:18.280] 就是比如说今天的chatbot\n",
            "[27:18.400 --> 27:20.840] 本质上跟chat gpt最大的区别\n",
            "[27:20.840 --> 27:23.040] 就是chatbot有他自己的agenda\n",
            "[27:23.120 --> 27:27.320] 他的agenda是背后一个2B的服务交付给某一家\n",
            "[27:27.320 --> 27:28.640] 他来deal我的\n",
            "[27:28.640 --> 27:29.880] 他来跟我应对的\n",
            "[27:30.000 --> 27:31.400] 他不是服务于我的\n",
            "[27:31.480 --> 27:33.400] 但我的个人助理一定是服务于我的\n",
            "[27:33.400 --> 27:34.880] 而且我要为他付钱的\n",
            "[27:34.960 --> 27:39.600] 我的数据必然是只用来为我的福祉来去努力\n",
            "[27:39.600 --> 27:41.880] 而且他不能够背叛我对吧\n",
            "[27:41.880 --> 27:43.000] 去跟别人deal\n",
            "[27:43.120 --> 27:45.600] 这种东西就意味着我们一定是要出钱的\n",
            "[27:45.600 --> 27:46.520] 我们要订阅的\n",
            "[27:46.520 --> 27:49.080] 我们要等于雇一个属于我们的助理\n",
            "[27:49.280 --> 27:52.280] 这里边的隐私和信任的问题都变得超级重要\n",
            "[27:52.320 --> 27:53.680] 如果不过这一关\n",
            "[27:53.680 --> 27:54.680] 刚才咱们说的问题\n",
            "[27:54.680 --> 27:58.320] 就是谁敢微信也不敢把自己的你的数据全捣出去\n",
            "[27:58.320 --> 28:00.520] 然后他如果不从你身上直接收钱\n",
            "[28:00.960 --> 28:02.800] 他一定就是拿你这个东西要去说\n",
            "[28:02.880 --> 28:03.920] 帮你推荐个产品\n",
            "[28:04.680 --> 28:07.160] 那个时候那一瞬间他不是背叛你的\n",
            "[28:07.240 --> 28:08.880] 他不是站在你的这一边的\n",
            "[28:08.960 --> 28:09.320] 对吧\n",
            "[28:09.320 --> 28:10.640] 所以这个就很麻烦\n",
            "[28:10.640 --> 28:12.440] 所以某种程度上我们如果简单的看\n",
            "[28:12.480 --> 28:14.720] 就解决隐私问题可能就是你得掏钱\n",
            "[28:14.720 --> 28:19.000] 你得让这个公司能够站在保护你隐私的方向\n",
            "[28:19.000 --> 28:20.320] 跑完他的商业闭关\n",
            "[28:20.320 --> 28:22.880] 这是一系列改变的一个indicator\n",
            "[28:23.440 --> 28:25.200] 能不能信任就是看谁掏钱\n",
            "[28:25.200 --> 28:26.600] 如果是免费的\n",
            "[28:26.600 --> 28:27.640] 你还真不敢用\n",
            "[28:28.560 --> 28:30.120] 我一直好奇一个问题\n",
            "[28:30.120 --> 28:32.840] 按现在这个速度发展来算的话\n",
            "[28:32.840 --> 28:36.040] 就是人类的数据应该很快就被用完掉了\n",
            "[28:36.400 --> 28:39.200] 人类的这些有用的数据都被用完之后\n",
            "[28:39.200 --> 28:40.440] 可能也就这两年的事\n",
            "[28:40.440 --> 28:41.000] 两三年的\n",
            "[28:41.640 --> 28:44.880] 应该是目前地球上所有人类的好的数据\n",
            "[28:44.880 --> 28:46.000] 全部都被用完了\n",
            "[28:46.000 --> 28:46.800] 然后呢\n",
            "[28:47.440 --> 28:48.240] 这个不好说\n",
            "[28:48.240 --> 28:51.120] 因为我觉得现在很多数据其实没有被使用\n",
            "[28:51.120 --> 28:52.720] 或者很多数据其实没有被记录\n",
            "[28:52.720 --> 28:56.160] 但这跟存储成本记录下来有没有用有关系\n",
            "[28:56.160 --> 28:57.320] 就还是打个比方\n",
            "[28:57.320 --> 28:59.480] 如果我们把我们每天听到的东西\n",
            "[28:59.480 --> 29:01.120] 7×24小时都记录下来\n",
            "[29:01.560 --> 29:03.200] 不是高质量的数据吗\n",
            "[29:03.400 --> 29:04.760] 你不是说日常吗\n",
            "[29:04.760 --> 29:06.680] 就比如说神经元\n",
            "[29:06.680 --> 29:10.120] 就是它有一部分就是让我们要睡觉吃饭\n",
            "[29:10.120 --> 29:11.080] 然后就是那些的\n",
            "[29:11.080 --> 29:13.320] 它不是那个for更好的计算\n",
            "[29:13.320 --> 29:15.320] 更高质量就是拿到结果那个部分\n",
            "[29:16.200 --> 29:18.240] 比如说这点讲到我们这样的一个对话\n",
            "[29:18.240 --> 29:21.840] 其实最后就不会进到他的某个训练机里面\n",
            "[29:22.120 --> 29:23.480] 我后续简称播客他会\n",
            "[29:24.000 --> 29:25.920] 但是我们就是人产生的数据\n",
            "[29:25.920 --> 29:28.840] 会远远弱于他吸收的速度\n",
            "[29:29.400 --> 29:31.440] 我觉得他以后没数据训练了怎么办\n",
            "[29:31.720 --> 29:33.600] 就一个很快就会发生的事情\n",
            "[29:34.960 --> 29:36.760] 旁转先定义一下数据\n",
            "[29:37.200 --> 29:38.920] 你先定义一下数据\n",
            "[29:39.000 --> 29:41.160] 比如在今天我们说数据这个词\n",
            "[29:41.400 --> 29:44.600] 咱们比如在你收到了很多信息\n",
            "[29:45.040 --> 29:46.960] 然后你甚至看那个信息的时候\n",
            "[29:46.960 --> 29:48.360] 你的反馈表情\n",
            "[29:48.360 --> 29:49.960] 你甚至停留的时长\n",
            "[29:50.240 --> 29:51.360] 大部分的时候\n",
            "[29:51.640 --> 29:53.080] 如果没有被记录的话\n",
            "[29:53.080 --> 29:54.160] 它其实也就不是数据\n",
            "[29:54.800 --> 29:56.440] 我们今天对于数据怎么定义\n",
            "[29:56.440 --> 29:59.440] 和在大模型时代对数据怎么定义\n",
            "[29:59.440 --> 30:01.760] 是不是本身数据的定义这个东西\n",
            "[30:01.760 --> 30:02.640] 就会有改变的\n",
            "[30:03.720 --> 30:04.120] 我不知道\n",
            "[30:04.120 --> 30:06.840] 我先暂且认为就是所有可以放到云上的\n",
            "[30:07.240 --> 30:09.240] 然后就是所有可以拷到硬盘里面的\n",
            "[30:10.240 --> 30:11.320] 是指那些\n",
            "[30:12.000 --> 30:13.440] 以后他就可以自己写\n",
            "[30:13.760 --> 30:16.680] 然后让张鹏看这文章怎么样打个分\n",
            "[30:17.040 --> 30:19.320] 然后你就从他的数字捞出来\n",
            "[30:19.320 --> 30:21.040] 就跟那个alphago一样\n",
            "[30:21.040 --> 30:22.000] alphazero\n",
            "[30:22.000 --> 30:24.320] 自己摆齐对吧\n",
            "[30:24.320 --> 30:26.760] 拿这些文字不断的去写\n",
            "[30:26.960 --> 30:29.640] 然后通过这个叫自学习\n",
            "[30:30.880 --> 30:32.720] 机器以后自己训练自己\n",
            "[30:32.720 --> 30:34.520] 自训练左右互搏\n",
            "[30:35.080 --> 30:37.880] 其实我觉得比如像潘乱\n",
            "[30:37.880 --> 30:40.480] 我为什么问怎么定义数据这件事\n",
            "[30:41.120 --> 30:43.240] 比如说大语言模型出来之后\n",
            "[30:43.240 --> 30:45.520] 他其实就是把所有人类\n",
            "[30:45.520 --> 30:48.560] 用人类语言的相关的这些信息\n",
            "[30:48.560 --> 30:51.680] 留存一下信息全部变成了有意义的数据\n",
            "[30:51.680 --> 30:53.960] 然后他可以去训练和学习\n",
            "[30:54.400 --> 30:57.600] 而以前比如说我们在训练自动驾驶的时候\n",
            "[30:57.800 --> 31:00.480] 你给他一张照片是要做标注的\n",
            "[31:00.800 --> 31:01.120] 对吧\n",
            "[31:01.120 --> 31:02.440] 就他在那个过程中\n",
            "[31:02.440 --> 31:05.560] 你其实能被真正结构化学习的数据是少的\n",
            "[31:05.560 --> 31:09.680] 而今天你自然语言就带来你指数级的数据的提升\n",
            "[31:09.680 --> 31:12.600] 而多模态又会带来比如你的视觉的\n",
            "[31:12.600 --> 31:13.120] 对吧\n",
            "[31:13.120 --> 31:14.440] 就是说的图片\n",
            "[31:14.440 --> 31:16.560] 所有的这些东西又会变成数据\n",
            "[31:16.560 --> 31:20.160] 所以在这里我记得上次我跟李志飞聊过这个问题\n",
            "[31:20.160 --> 31:22.640] 虽然他说的大的细节我记不住\n",
            "[31:22.640 --> 31:26.520] 但他认为应该还有8到10个数量级的\n",
            "[31:26.520 --> 31:29.000] 数据的提升的空间\n",
            "[31:29.000 --> 31:30.800] 因为这里的包含了多模态\n",
            "[31:30.840 --> 31:32.400] 包含了更多的这些东西\n",
            "[31:32.400 --> 31:34.640] 所以它不至于像咱们想的说\n",
            "[31:34.640 --> 31:36.840] 这个再用几年就结束了\n",
            "[31:36.840 --> 31:38.920] 因为它本身随着它的能力提升\n",
            "[31:38.920 --> 31:40.640] 数据意味着什么\n",
            "[31:40.840 --> 31:43.800] 更多的数据也会因此而诞生\n",
            "[31:43.800 --> 31:46.480] 就这个东西可能还会让它能够提高\n",
            "[31:46.480 --> 31:48.920] 所以没有那么轻易可能能看到它的终点了\n",
            "[31:49.680 --> 31:50.120] OK\n",
            "[31:50.120 --> 31:53.200] 反正大家都认为以后AI基于自己的数据训练\n",
            "[31:53.200 --> 31:54.800] 就是\n",
            "[31:54.800 --> 31:58.200] 你要知道这个家伙以后真的不是被我们定义了\n",
            "[31:58.200 --> 31:59.760] 它是全知全能\n",
            "[31:59.760 --> 32:00.640] 这很可怕的\n",
            "[32:00.680 --> 32:02.920] 我现在想起来都觉得很厉害\n",
            "[32:02.920 --> 32:04.960] 所以未来复盛他们的机器人\n",
            "[32:04.960 --> 32:07.040] 这个脑子一旦又变好了之后\n",
            "[32:07.040 --> 32:08.240] 我觉得挺可怕的\n",
            "[32:08.240 --> 32:10.960] 以后复盛你要防止这个叫什么来着\n",
            "[32:10.960 --> 32:12.920] 就是那个Terminator\n",
            "[32:12.920 --> 32:14.680] 这个事真不是胡说八道了\n",
            "[32:14.680 --> 32:15.880] 以后真是有可能的\n",
            "[32:16.960 --> 32:18.240] 来我们聊聊产品吧\n",
            "[32:18.240 --> 32:19.440] 那个我先问问啊\n",
            "[32:19.440 --> 32:22.320] 俊宇你应该也把那个New Beam\n",
            "[32:22.320 --> 32:23.280] 你也体验过了\n",
            "[32:23.280 --> 32:25.080] 你怎么看这个New Beam\n",
            "[32:25.080 --> 32:28.720] 把这个Chat GPT用到这个搜索里面\n",
            "[32:28.720 --> 32:30.040] 你的感觉是怎么样的\n",
            "[32:30.040 --> 32:31.920] 你觉得搜索引擎会因此有什么变化吗\n",
            "[32:31.920 --> 32:33.120] 潘老师也说过\n",
            "[32:33.120 --> 32:35.680] 对他现在说我的首选是搜索引擎\n",
            "[32:35.680 --> 32:38.560] 我一开始会觉得说这个是一个很取巧的一个做法\n",
            "[32:38.560 --> 32:41.800] 就是说他其实把一个聊天框跟一个搜索框\n",
            "[32:41.800 --> 32:43.120] 给复制粘贴\n",
            "[32:43.120 --> 32:45.400] 把它用透明胶粘到了一起\n",
            "[32:45.400 --> 32:48.360] 其实一开始会觉得是一种挺生硬的组合的\n",
            "[32:48.360 --> 32:52.040] 你也可以想象说为什么Google号称自己做了Budget\n",
            "[32:52.040 --> 32:54.680] 但一直不愿意把它给放上去\n",
            "[32:54.680 --> 32:57.200] Google可能一直觉得说这种自然语言的交互\n",
            "[32:57.200 --> 32:59.600] 跟搜索框这种基于关键词\n",
            "[32:59.600 --> 33:02.360] 基于文本的交互其实不是一回事\n",
            "[33:02.360 --> 33:05.240] 他们不想把它那么粗暴的粘到一起去\n",
            "[33:05.240 --> 33:06.720] 但坦白讲事实上来讲\n",
            "[33:06.720 --> 33:08.800] 我现在用New Beam其实也不怎么用它搜索框\n",
            "[33:08.800 --> 33:09.960] 或者是提问为主\n",
            "[33:09.960 --> 33:12.640] 所以其实也还是没有把它给粘到一起\n",
            "[33:12.640 --> 33:15.400] 然后我现在还是会观察说我的使用的行为\n",
            "[33:15.400 --> 33:19.520] 就是说当我涉及到一些有点复杂的问题的时候\n",
            "[33:19.520 --> 33:21.480] 我就会选择去用New Beam\n",
            "[33:21.480 --> 33:25.840] 因为其实我觉得GPT它作为一个把结构化数据\n",
            "[33:25.840 --> 33:30.160] 转化成自然语言的一个很高效率的一个工具\n",
            "[33:30.160 --> 33:36.800] 它能帮我在很短时间内去提取比较复杂的文档里面关键的信息\n",
            "[33:36.800 --> 33:42.040] 其实有点像我们前几天讨论是说听播客和看文章的区别\n",
            "[33:42.040 --> 33:42.840] 因为听播客嘛\n",
            "[33:42.840 --> 33:44.040] 你有点就自然语言\n",
            "[33:44.040 --> 33:46.400] 有个人给你娓娓道来给你讲\n",
            "[33:46.400 --> 33:47.520] 虽然你不会跟他交互\n",
            "[33:47.520 --> 33:49.800] 但他毕竟是给你在讲述一个东西\n",
            "[33:49.800 --> 33:52.400] 他是一个大家与生俱来都懂的\n",
            "[33:52.400 --> 33:53.880] 就是怎么去听别人说话\n",
            "[33:53.880 --> 33:57.280] 怎么去跟别人去对话这样的一个过程\n",
            "[33:57.280 --> 34:00.800] 那读文字来讲毕竟是一个需要习得的一个能力\n",
            "[34:00.800 --> 34:03.640] 但因为我现在无人乱七还不是那个edge\n",
            "[34:03.640 --> 34:07.040] 所以很多时候如果说我就是知道我要找什么东西\n",
            "[34:07.040 --> 34:08.120] 我还是会用Google\n",
            "[34:08.120 --> 34:10.800] 比如说我就是要去Wikipedia找一个什么东西\n",
            "[34:10.800 --> 34:12.920] 我就是要查一个东西是什么一回事\n",
            "[34:12.920 --> 34:14.600] 但稍微这个问题有点复杂的时候\n",
            "[34:14.600 --> 34:16.480] 我一般就会用Beam来问\n",
            "[34:16.480 --> 34:19.920] 比如说某个可能跟我写程序有关的\n",
            "[34:19.920 --> 34:20.960] 因为我也不是程序员\n",
            "[34:20.960 --> 34:22.400] 跟傅政老师差不多\n",
            "[34:22.400 --> 34:25.280] 可能也是在写程序方面也是一个非常\n",
            "[34:25.280 --> 34:28.960] 主要是我一个黑暗三角包的一个状态\n",
            "[34:28.960 --> 34:31.160] 然后就经常看到很多Dbug的问题\n",
            "[34:31.160 --> 34:32.280] 或者他报一个什么错误\n",
            "[34:32.280 --> 34:35.840] 就经常会去问Beam到底是什么意思\n",
            "[34:35.840 --> 34:39.200] 然后我要装他说我缺了一个什么包\n",
            "[34:39.200 --> 34:40.880] 这个包到底怎么去装\n",
            "[34:40.880 --> 34:42.040] 然后他会问我一些\n",
            "[34:42.040 --> 34:45.200] 其实Beam会他后面用GPT-4他会问你一些问题\n",
            "[34:45.200 --> 34:48.200] 其实跟你跟真人讨论是很像的\n",
            "[34:48.200 --> 34:49.240] 他会问你一些问题\n",
            "[34:49.240 --> 34:51.680] 然后你再去作答\n",
            "[34:51.800 --> 34:54.520] 然后他这样是一个更交互式的一个去\n",
            "[34:54.520 --> 34:56.080] 获得信息的一个过程\n",
            "[34:56.080 --> 34:58.760] 我觉得对于这种相对来讲比较复杂的\n",
            "[34:58.760 --> 35:00.800] 尤其是他可能需要读\n",
            "[35:00.800 --> 35:02.880] 其实因为有人是把Beam后面的\n",
            "[35:02.880 --> 35:04.520] 这个Promote给偷了出来\n",
            "[35:04.520 --> 35:07.440] 就是通过这种Promote注入的方法偷了出来\n",
            "[35:07.440 --> 35:09.600] 其实你大概能够看到他的一些原理\n",
            "[35:09.600 --> 35:14.160] 让他通过传统的搜索引擎去找到可能4篇5篇文章\n",
            "[35:14.160 --> 35:16.480] 然后他其实通过GPT能力去做整合\n",
            "[35:16.480 --> 35:18.040] 其实他做的就是这个事情\n",
            "[35:18.040 --> 35:19.840] 对你给他开四五个文档\n",
            "[35:19.840 --> 35:20.720] 然后问他一个问题\n",
            "[35:20.720 --> 35:21.400] 他做一个整合\n",
            "[35:21.400 --> 35:23.560] 直接告诉你一个比较快的答案\n",
            "[35:23.560 --> 35:24.440] 这事来讲的话\n",
            "[35:24.440 --> 35:25.920] 在你很快的情况下\n",
            "[35:25.920 --> 35:27.440] 在你很着急的情况下来讲\n",
            "[35:27.440 --> 35:30.240] 还是给你自己去读要快的读\n",
            "[35:30.240 --> 35:33.800] 所以我觉得这点其实还是能给我带来一个很新的体验\n",
            "[35:33.800 --> 35:36.840] 我自己并没有多强的使用上的感受\n",
            "[35:36.840 --> 35:40.400] 因为感觉这还是停在最初GPT\n",
            "[35:40.400 --> 35:42.560] 那个给人的震撼上的感觉\n",
            "[35:42.560 --> 35:46.840] 他只是比那个Trade GPT好了一点点\n",
            "[35:46.840 --> 35:49.200] 就是他遵循了互联网的协议\n",
            "[35:49.240 --> 35:52.480] 就是加了内容的引用来源\n",
            "[35:52.480 --> 35:53.840] 然后我看的更多就是\n",
            "[35:53.840 --> 35:56.240] 这很快就是过了一日活了\n",
            "[35:56.240 --> 35:58.720] 我自己更多是从这种商业上的\n",
            "[35:58.720 --> 36:00.760] 就是这公司竞争上的一个感受\n",
            "[36:00.760 --> 36:02.240] 你说实际上他说\n",
            "[36:02.240 --> 36:03.480] 他尽管给你一二三\n",
            "[36:03.480 --> 36:05.080] 但他在很多情况下\n",
            "[36:05.080 --> 36:07.040] 他也还是\n",
            "[36:07.040 --> 36:07.960] 也不能说很多情况\n",
            "[36:08.400 --> 36:09.880] 你看他就是主推的例子\n",
            "[36:10.080 --> 36:11.360] 他主推例子就是说\n",
            "[36:11.360 --> 36:13.960] 我现在要举办6个人的晚宴\n",
            "[36:13.960 --> 36:16.120] 你能不能帮我推三道\n",
            "[36:16.120 --> 36:18.840] 不包括坚果和海鲜的菜\n",
            "[36:19.080 --> 36:21.360] 然后他直接从网上搜索\n",
            "[36:21.360 --> 36:23.240] 然后从知乎的专栏\n",
            "[36:23.240 --> 36:24.880] 然后从各种的地方\n",
            "[36:25.400 --> 36:27.240] 抓了可能是五六个链接\n",
            "[36:27.240 --> 36:29.280] 然后把那些专栏里面的答案\n",
            "[36:29.280 --> 36:30.800] 有用的答案给你拼接出来\n",
            "[36:30.800 --> 36:32.240] 然后给你推荐了几道菜\n",
            "[36:32.240 --> 36:34.320] 比如说青炒西兰花\n",
            "[36:34.320 --> 36:37.440] 酱爆五花肉和鸡肉香菇豆腐皮卷\n",
            "[36:37.440 --> 36:39.240] 就是这些有用的东西\n",
            "[36:39.240 --> 36:40.440] 它是\n",
            "[36:41.280 --> 36:44.480] 我也不知道怎么更好去说这个问题\n",
            "[36:44.800 --> 36:46.840] 但这个东西还是GPT的能力\n",
            "[36:47.320 --> 36:49.480] 只是说今天他是让大家\n",
            "[36:49.480 --> 36:51.000] 就刚才俊逸说的是\n",
            "[36:51.000 --> 36:52.800] 是向他提问\n",
            "[36:52.800 --> 36:55.080] 不是去获得某个\n",
            "[36:55.080 --> 36:57.200] 像之前搜索那样去获得\n",
            "[36:57.200 --> 36:58.520] 我觉得跟之前搜索\n",
            "[36:58.520 --> 36:59.680] 其实是不一样的\n",
            "[37:00.280 --> 37:01.560] 对你原来的搜索\n",
            "[37:01.680 --> 37:03.200] 实际上就是给你一个\n",
            "[37:03.200 --> 37:05.440] 通向你要找目标的通道\n",
            "[37:05.480 --> 37:06.720] 但今天的提问\n",
            "[37:06.840 --> 37:08.760] 它更像是你的一个向导\n",
            "[37:08.760 --> 37:09.640] 你问他\n",
            "[37:09.640 --> 37:11.720] 他可能给你导到某些方向上去\n",
            "[37:11.720 --> 37:13.080] 这两个是有区别的\n",
            "[37:13.080 --> 37:14.840] 对我就有点像那种\n",
            "[37:14.840 --> 37:16.240] 就是比如说你看之前\n",
            "[37:16.240 --> 37:17.800] 我就记得阿北做兜办的时候\n",
            "[37:17.800 --> 37:19.760] 把兜办就是那些树影\n",
            "[37:19.920 --> 37:23.080] 它封成看前看中看后\n",
            "[37:23.120 --> 37:24.920] 他做的其实是兜办\n",
            "[37:24.920 --> 37:26.520] 做的是一个发现的路径\n",
            "[37:26.600 --> 37:29.520] 但他其实就是有这个输评没输\n",
            "[37:29.520 --> 37:31.480] 然后有影评没视频\n",
            "[37:31.480 --> 37:32.760] 然后我觉得今天\n",
            "[37:32.760 --> 37:34.040] 其实之前的搜索引擎\n",
            "[37:34.040 --> 37:35.480] 它核心干的事情就是链接\n",
            "[37:36.320 --> 37:37.200] 其实是搜索引擎\n",
            "[37:37.200 --> 37:39.320] 是为了让用户更快的去离开你\n",
            "[37:39.320 --> 37:40.760] 然后去到目的地的\n",
            "[37:40.760 --> 37:43.200] 然后但是今天就是newbeam\n",
            "[37:43.200 --> 37:44.200] 跟那个beam\n",
            "[37:44.560 --> 37:46.200] 跟搜索引擎比较大的不一样\n",
            "[37:46.200 --> 37:48.640] 就是说它就是目的地本身\n",
            "[37:48.640 --> 37:50.520] 它不是你去往目的地的\n",
            "[37:50.520 --> 37:52.240] 连接的桥梁\n",
            "[37:52.600 --> 37:55.640] 它直接变成了最终结果的承载页\n",
            "[37:56.120 --> 37:57.120] 金宇先说\n",
            "[37:57.120 --> 37:58.240] 对他其实还是说\n",
            "[37:58.240 --> 37:59.960] 他的原理还是把最后搜索结果\n",
            "[37:59.960 --> 38:01.720] 里面的三或者四个网页\n",
            "[38:01.720 --> 38:03.000] 给提取了出来\n",
            "[38:03.000 --> 38:04.240] 然后告诉你它的结果\n",
            "[38:04.240 --> 38:05.680] 但从商业模式上面\n",
            "[38:05.680 --> 38:06.520] 从浏览模式上面\n",
            "[38:06.520 --> 38:08.840] 的确会对网站会有些挑战\n",
            "[38:08.840 --> 38:09.880] 但它其实还是\n",
            "[38:09.880 --> 38:12.080] 后面接的还是一个传统的搜索引擎\n",
            "[38:12.200 --> 38:13.880] 我正好在翻我在Bing上面的搜索\n",
            "[38:13.880 --> 38:15.400] 接触比如说我前两天搜了一个\n",
            "[38:15.400 --> 38:16.600] 特别简单的一个问题\n",
            "[38:16.600 --> 38:19.200] 如何在Mac上面去安装Python\n",
            "[38:19.200 --> 38:21.480] 对我那天肯定在跑OpenAI的SDK\n",
            "[38:21.480 --> 38:23.800] 然后他说我Python版本不对之类的\n",
            "[38:23.800 --> 38:25.520] 然后我以为我没有装Python\n",
            "[38:25.520 --> 38:26.720] 然后就问他这个问题\n",
            "[38:26.720 --> 38:28.880] 然后我记得他当时就一步步引导下来\n",
            "[38:28.880 --> 38:31.360] 说那你到底要用什么来装什么\n",
            "[38:31.360 --> 38:33.640] 那其实它的原始的出处\n",
            "[38:33.640 --> 38:35.520] 可能是来自四五个不同的文档\n",
            "[38:35.520 --> 38:37.840] 你本来可能是需要这四五个文档都看完\n",
            "[38:37.840 --> 38:39.800] 然后自己去做些整合\n",
            "[38:39.800 --> 38:41.560] 你要理解到里面的一些概念到底是什么\n",
            "[38:41.560 --> 38:43.200] 什么叫homebrew之类的\n",
            "[38:43.240 --> 38:45.360] 然后他其实就把这些东西都读完以后\n",
            "[38:45.360 --> 38:48.000] 然后给你做了一些总结提取\n",
            "[38:48.000 --> 38:49.920] 做一些进一步的classification\n",
            "[38:50.280 --> 38:52.320] 我觉得从一个效率工具来说还是挺麻烦的\n",
            "[38:53.920 --> 38:56.840] 傅胜用Nubing的体验是怎么样的\n",
            "[38:58.040 --> 39:00.760] 就是我一直在他waitlist里\n",
            "[39:00.760 --> 39:02.080] 他说就没怎么用\n",
            "[39:02.080 --> 39:04.480] 但我因为现在每天都大量跳GDT\n",
            "[39:04.480 --> 39:08.040] 所以其实就很少用搜索了\n",
            "[39:08.480 --> 39:10.840] 正好跟俊逸讲的是一样的\n",
            "[39:10.840 --> 39:12.240] 我就要装Python\n",
            "[39:12.240 --> 39:13.800] 然后我就是问全GDP\n",
            "[39:13.800 --> 39:15.560] 我说我要装怎么装\n",
            "[39:15.560 --> 39:17.000] 然后我在MacD要怎么装\n",
            "[39:17.000 --> 39:18.680] 他就劈啪拉给我命令符\n",
            "[39:18.680 --> 39:19.280] 我就去打\n",
            "[39:19.280 --> 39:20.840] 打了以后就会有时候会出错\n",
            "[39:20.840 --> 39:22.840] 出错了我就把错误信息再贴给他\n",
            "[39:22.840 --> 39:25.800] 然后他告诉我哪个地方你用什么就弄\n",
            "[39:25.800 --> 39:28.040] 甚至到有一个他给了我\n",
            "[39:28.040 --> 39:29.640] 当时要装一个包\n",
            "[39:29.640 --> 39:31.680] 然后给了我一个命令行\n",
            "[39:31.680 --> 39:33.160] 装的时候那个就\n",
            "[39:33.160 --> 39:35.640] 因为GitHub网站的一个命令行\n",
            "[39:35.640 --> 39:36.520] 你知道吗\n",
            "[39:36.520 --> 39:38.200] 你知道我从来没用过终端\n",
            "[39:38.200 --> 39:41.520] 这些就在苹果下我都没用过的\n",
            "[39:41.560 --> 39:44.400] 然后那个就是整个过程\n",
            "[39:44.400 --> 39:45.640] 就他一步步教我\n",
            "[39:45.640 --> 39:47.360] 然后有一个GitHub访问不了\n",
            "[39:47.360 --> 39:49.320] 我说我这个访问不了我在中国\n",
            "[39:49.320 --> 39:50.400] 他说好那嘣\n",
            "[39:50.400 --> 39:52.080] 就给我一个清华大学的链接\n",
            "[39:52.080 --> 39:53.200] 然后我再点进去\n",
            "[39:53.200 --> 39:55.360] 然后视频下载机上站又装\n",
            "[39:55.360 --> 39:56.000] 然后又这样\n",
            "[39:56.000 --> 39:58.640] 我说我就从那个40点点起\n",
            "[39:58.640 --> 40:00.040] 我从两边连来点去\n",
            "[40:00.040 --> 40:01.040] 有时候我都搞错了\n",
            "[40:01.040 --> 40:05.040] 我把那个Python的运行环境和这个终端搞错了\n",
            "[40:05.040 --> 40:05.440] 你知道吗\n",
            "[40:05.440 --> 40:07.600] 他说你这不是在终端下\n",
            "[40:07.600 --> 40:08.560] 你在运行环境下\n",
            "[40:08.560 --> 40:10.240] 因为我把错误信息贴给他\n",
            "[40:10.240 --> 40:11.360] 你要找到终端\n",
            "[40:11.360 --> 40:15.120] 所以完全靠这个就全完成了\n",
            "[40:15.120 --> 40:19.480] 所以其实我认为这的确是搜索形态的一个变革\n",
            "[40:19.480 --> 40:21.400] 就是他把原来就AIGC了\n",
            "[40:21.400 --> 40:23.760] 他把多个内容给你整理出来\n",
            "[40:23.760 --> 40:26.040] 因为其实我们虽然在搜索内容\n",
            "[40:26.040 --> 40:30.760] 但是事实上网上存在内容和你要搜索目的之间是有一定偏差的\n",
            "[40:30.760 --> 40:32.800] 所以你经常在网页当中去寻找\n",
            "[40:32.800 --> 40:34.240] 就自己再去组织\n",
            "[40:34.240 --> 40:36.320] 他等于把这件事帮你做\n",
            "[40:36.320 --> 40:36.960] 对吧\n",
            "[40:36.960 --> 40:40.960] 当然对对这个生态网站肯定就会有影响吧\n",
            "[40:41.000 --> 40:42.440] 这个到底会怎么影响\n",
            "[40:42.440 --> 40:44.120] 这短再看呗\n",
            "[40:44.120 --> 40:45.800] 他会不会变成了一个巨无霸\n",
            "[40:45.800 --> 40:46.880] 所有都是他的\n",
            "[40:46.880 --> 40:47.440] 对吧\n",
            "[40:47.440 --> 40:50.760] 还是我们在和他的运用当中还是能做出一些东西的\n",
            "[40:50.760 --> 40:56.000] 因为我看他现在开放接口就是你可以把你自己有一些东西和他的引擎能力结合起来\n",
            "[40:56.000 --> 40:57.960] 然后还是先给你的私有数据\n",
            "[40:57.960 --> 40:59.680] 所以为什么谷歌这次这么紧张呢\n",
            "[40:59.680 --> 41:00.760] 我觉得未来的搜索\n",
            "[41:00.760 --> 41:03.640] 包括这些百度为什么跳出来一定要开发部会呢\n",
            "[41:03.640 --> 41:07.120] 就首先搜索厂商是必然被变革的\n",
            "[41:07.120 --> 41:08.080] 谷歌的对吧\n",
            "[41:08.080 --> 41:10.280] 那占有率在美国都多少年不动了\n",
            "[41:10.280 --> 41:14.600] 微软又这个又买牙火又弄搞了半天搞不动他就这么一个东西\n",
            "[41:14.600 --> 41:16.480] 碰一发出来\n",
            "[41:16.480 --> 41:17.960] 谷歌已经降了几个点了\n",
            "[41:17.960 --> 41:20.240] 这个微软上一个月火了\n",
            "[41:20.240 --> 41:21.840] 而且随着这个各种应用\n",
            "[41:21.840 --> 41:24.640] 他为什么这次把那个API开放的那么好\n",
            "[41:24.640 --> 41:26.920] 我就觉得他肯定也考虑清楚了\n",
            "[41:26.920 --> 41:29.600] 必须大量人帮他做应用做魔法石\n",
            "[41:29.600 --> 41:29.920] 对吧\n",
            "[41:29.920 --> 41:31.680] 现在美国不已经开始招这种吧\n",
            "[41:31.680 --> 41:33.040] ProMIT工程师\n",
            "[41:33.040 --> 41:34.960] 因为大部分用户还不太懂\n",
            "[41:34.960 --> 41:37.240] 他不会去那样的发问\n",
            "[41:37.240 --> 41:39.920] 但是通过几个问题能不能直达你的问题\n",
            "[41:39.960 --> 41:43.560] 所以就会有有这样的一些应用的出现\n",
            "[41:43.560 --> 41:45.000] 所以整个搜索\n",
            "[41:45.000 --> 41:46.600] 甚至那天我跟百度人都在聊\n",
            "[41:46.600 --> 41:51.000] 我说可能以后搜索的这个收费模式都会改变\n",
            "[41:51.000 --> 41:53.400] 因为以前由于你去排结果\n",
            "[41:53.400 --> 41:55.320] 所以其实就谁有钱谁老大对吧\n",
            "[41:55.320 --> 41:57.160] 那你就有钱的就得排前面\n",
            "[41:57.160 --> 41:59.080] 这样就不就广为诟病了\n",
            "[41:59.080 --> 42:00.280] 你现在是对吧\n",
            "[42:00.280 --> 42:01.960] 我是给你重新生存内容\n",
            "[42:01.960 --> 42:04.080] 那就是我的内容越真实\n",
            "[42:04.080 --> 42:06.680] 越真知灼见越能帮你节约时间\n",
            "[42:06.680 --> 42:08.480] 我觉得有价值\n",
            "[42:08.520 --> 42:11.080] 我说没准以后所有引擎都是付费了\n",
            "[42:11.080 --> 42:11.560] 有道理\n",
            "[42:11.560 --> 42:13.240] 普通问题来两下\n",
            "[42:13.240 --> 42:14.360] 这就是我说的\n",
            "[42:14.360 --> 42:16.480] 如果我就是又为你好\n",
            "[42:16.480 --> 42:18.000] 我没有自己的额沾大\n",
            "[42:18.000 --> 42:20.360] 没有自己背后的理由对吧\n",
            "[42:20.360 --> 42:21.920] 那我就管你收钱就好了\n",
            "[42:21.920 --> 42:22.720] 你才能信任我\n",
            "[42:22.720 --> 42:24.240] 我就专心为你\n",
            "[42:24.240 --> 42:26.800] 否则背后肯定有猫腻\n",
            "[42:26.800 --> 42:28.000] 对你再想想\n",
            "[42:28.000 --> 42:30.400] 就因为这次GDP是有一个指标吗\n",
            "[42:30.400 --> 42:31.080] 大家都在说\n",
            "[42:31.080 --> 42:31.320] 哇\n",
            "[42:31.320 --> 42:33.040] 他居然超过律师考试了\n",
            "[42:33.040 --> 42:35.200] 能够得已经10%的人了\n",
            "[42:35.200 --> 42:38.160] 我说反过来是不是因为美国律师太贵呀\n",
            "[42:38.200 --> 42:42.160] 我靠OpenAI就直接就把这部分作为重点了\n",
            "[42:42.160 --> 42:42.480] 对吧\n",
            "[42:42.480 --> 42:45.200] 你请个律师一个小时的意见咨询\n",
            "[42:45.200 --> 42:46.320] 几百美金\n",
            "[42:46.320 --> 42:48.080] 这个给一个月20美金\n",
            "[42:48.080 --> 42:49.440] 你付不付\n",
            "[42:49.440 --> 42:49.720] 对吧\n",
            "[42:49.720 --> 42:51.240] 我就把它当这个用\n",
            "[42:51.240 --> 42:53.400] 其实以前要么就自己到网上去看那个\n",
            "[42:53.400 --> 42:55.040] 耗如烟海的那些文档\n",
            "[42:55.040 --> 42:57.400] 看完这个整个人都麻的\n",
            "[42:57.400 --> 43:00.320] 他没准是把这个当成第一个Keynote应用\n",
            "[43:00.320 --> 43:02.280] 给认真做了一下\n",
            "[43:02.280 --> 43:04.120] 因为我觉得按照他的能力\n",
            "[43:04.120 --> 43:06.200] 他要做哪一块都能做得很好\n",
            "[43:06.200 --> 43:08.320] 只是他肯定是要有数据侧重的\n",
            "[43:08.320 --> 43:11.200] 他先把律师这个给宣了再说\n",
            "[43:11.760 --> 43:13.520] 的确会产生比较深远的影响\n",
            "[43:13.520 --> 43:14.360] 你就像百度\n",
            "[43:14.360 --> 43:16.000] 他其实是前一段\n",
            "[43:16.000 --> 43:18.880] 我记得前两年的万象的发布会上\n",
            "[43:18.880 --> 43:21.280] 还在推他们其中的一个问一问\n",
            "[43:21.280 --> 43:22.640] 这样的一个业务\n",
            "[43:22.640 --> 43:23.840] 其实是用户付费\n",
            "[43:23.960 --> 43:25.400] 然后去向专家问\n",
            "[43:25.400 --> 43:27.120] 那个专家可能是律师\n",
            "[43:27.120 --> 43:28.280] 也可能是情感专家\n",
            "[43:28.280 --> 43:29.320] 可能是心理专家\n",
            "[43:29.320 --> 43:32.400] 然后也可能是其他各行各业的\n",
            "[43:32.920 --> 43:35.200] 但其实如果今天有这个大模型之后\n",
            "[43:35.800 --> 43:39.680] 他就不需要你一个个真人在那边提供\n",
            "[43:39.680 --> 43:41.920] 就因为大模型它可以很快的\n",
            "[43:41.920 --> 43:43.520] 达到纯整线上\n",
            "[43:43.520 --> 43:45.560] 或者说超过95%的人的水平\n",
            "[43:45.720 --> 43:48.080] 人在那边的供给\n",
            "[43:48.960 --> 43:49.360] 对吧\n",
            "[43:49.360 --> 43:51.640] 尤其你看包括大家去医院\n",
            "[43:51.640 --> 43:54.360] 都是你排队两小时就看五分钟\n",
            "[43:55.280 --> 43:56.840] 其实就问几句话\n",
            "[43:57.080 --> 43:59.240] 你医生也不一定是最好的医生\n",
            "[43:59.880 --> 44:00.320] 有道理\n",
            "[44:00.520 --> 44:02.840] 我觉得刚才傅胜说的推论\n",
            "[44:02.840 --> 44:04.200] 还真有可能成立\n",
            "[44:04.400 --> 44:06.480] 因为我们看OpenAI\n",
            "[44:07.080 --> 44:08.600] 我们接着再聊一个产品\n",
            "[44:08.600 --> 44:10.760] 这个产品正好顺着这个路线\n",
            "[44:11.120 --> 44:12.480] 这个产品叫Speak\n",
            "[44:12.480 --> 44:14.240] 实际上是语言教育的产品\n",
            "[44:14.240 --> 44:17.280] 这个也是OpenAI直接就参与投资的\n",
            "[44:17.760 --> 44:18.960] 我看是他投资吗\n",
            "[44:18.960 --> 44:21.560] 对领头2700万美金的碧轮\n",
            "[44:21.760 --> 44:22.920] 语言的教育\n",
            "[44:22.920 --> 44:25.320] 以前语言教育的老师也是会的\n",
            "[44:25.560 --> 44:25.840] 对吧\n",
            "[44:25.840 --> 44:28.200] 然后这个应用我不知道有没有人用过\n",
            "[44:28.360 --> 44:29.440] 这个Speak\n",
            "[44:29.440 --> 44:31.680] 当然这个好像是个韩国的产品\n",
            "[44:31.880 --> 44:34.440] 就是让我们的团队也都体验过\n",
            "[44:34.440 --> 44:36.200] 我可以跟大家描述描述\n",
            "[44:36.680 --> 44:39.000] 这个英语学习的产品\n",
            "[44:39.000 --> 44:40.080] 它很重要的一点\n",
            "[44:40.240 --> 44:42.160] 就是首先是付费模式\n",
            "[44:42.360 --> 44:44.440] 这个提供阅读和年度订阅\n",
            "[44:44.440 --> 44:47.280] 然后除了人工智能的练习指导之外\n",
            "[44:47.280 --> 44:50.400] 然后用户还可以有这种课程选修课\n",
            "[44:50.400 --> 44:52.360] 它很新的一个很重要的一点\n",
            "[44:52.360 --> 44:53.720] 叫AI的Tutor\n",
            "[44:53.840 --> 44:56.680] 让语言学习者能够在APP内\n",
            "[44:56.680 --> 44:58.920] 进行开放式的对话\n",
            "[44:59.240 --> 45:00.800] 就语音的\n",
            "[45:01.000 --> 45:04.760] 就是你就拿语音跟手机里的AI就在聊天\n",
            "[45:04.760 --> 45:07.080] 他就拿语音跟你在反过来交流\n",
            "[45:07.080 --> 45:08.080] 那个不是老师\n",
            "[45:08.080 --> 45:10.320] 你可以理解为一个外教\n",
            "[45:10.320 --> 45:11.680] 就你雇的一个外教\n",
            "[45:11.680 --> 45:14.240] 但以前一个外教按小时收费的\n",
            "[45:14.240 --> 45:16.160] 这个是你可以包棉的\n",
            "[45:16.160 --> 45:16.520] 对吧\n",
            "[45:16.520 --> 45:18.160] 这成本一定是很低的\n",
            "[45:18.160 --> 45:19.080] 然后在这里边\n",
            "[45:19.080 --> 45:20.040] 你如果有错\n",
            "[45:20.040 --> 45:21.520] 比如你语法有错语音有错\n",
            "[45:21.520 --> 45:22.840] 他后来还会提示你\n",
            "[45:22.840 --> 45:24.400] 就有一些文本的提示\n",
            "[45:24.680 --> 45:26.520] 就是告诉你哪错了\n",
            "[45:26.520 --> 45:27.320] 你后头怎么改\n",
            "[45:27.440 --> 45:28.920] 而且补充一下\n",
            "[45:29.120 --> 45:32.040] 在GPD4这次说的叫多灵果\n",
            "[45:32.360 --> 45:34.320] 也是个语言教育的软件\n",
            "[45:34.320 --> 45:36.280] 里边已经实现了\n",
            "[45:36.280 --> 45:38.000] 你如果跟他聊天的时候聊错了\n",
            "[45:38.000 --> 45:39.480] 他直接拿语音纠正你\n",
            "[45:39.480 --> 45:41.520] 就他在用对话的方式纠正你\n",
            "[45:41.920 --> 45:43.360] 你刚才说的我听懂了\n",
            "[45:43.360 --> 45:45.600] 但是你里边刚才有一个什么东西\n",
            "[45:45.600 --> 45:47.280] 其实更好的说法是怎么怎么样\n",
            "[45:47.520 --> 45:51.080] 你已经完全变成了一个实时的在线的老师\n",
            "[45:51.600 --> 45:53.040] 这个东西就很明显\n",
            "[45:53.400 --> 45:54.320] 从原来很贵\n",
            "[45:54.320 --> 45:55.280] 你要按小时的\n",
            "[45:55.280 --> 45:57.680] 变成你就按个交个月费就好了\n",
            "[45:57.680 --> 45:58.000] 对吧\n",
            "[45:58.040 --> 45:59.200] 就几十美金\n",
            "[45:59.200 --> 46:00.600] 就基本是这么一个感觉\n",
            "[46:00.600 --> 46:02.000] 所以这个产品\n",
            "[46:02.360 --> 46:03.720] 我也想问问大家\n",
            "[46:03.920 --> 46:07.240] 你们觉得未来是不是教育类的产品\n",
            "[46:07.400 --> 46:09.560] 又要出现根本性的变革了\n",
            "[46:09.560 --> 46:10.680] 尤其是语言的\n",
            "[46:11.160 --> 46:14.840] 我觉得大力教育下面有一款产品叫开业英语\n",
            "[46:14.840 --> 46:16.320] 可能跟你说的是类似的\n",
            "[46:16.320 --> 46:18.440] 就是鼓励大家是那种对话会合制\n",
            "[46:18.440 --> 46:19.880] 然后往前去走的\n",
            "[46:20.000 --> 46:22.800] 我觉得自己是不是考虑教育那块业务\n",
            "[46:22.800 --> 46:24.160] 又有事情可以干了\n",
            "[46:24.160 --> 46:26.600] 就是因为这个产品是几个老板\n",
            "[46:26.800 --> 46:28.360] 自己在里面花了很多精力的\n",
            "[46:28.360 --> 46:31.080] 尽管他没有在这件事情上\n",
            "[46:31.080 --> 46:33.000] 花很大的市场的开销\n",
            "[46:33.000 --> 46:36.120] 但是他们自己投了很大精力的投入\n",
            "[46:36.720 --> 46:38.720] 感觉可以再拉出来再做一遍\n",
            "[46:39.720 --> 46:42.280] 就是继续大力出奇迹 对吧\n",
            "[46:42.800 --> 46:44.920] 就玉觉得这种教育类的产品\n",
            "[46:44.920 --> 46:46.600] 就以前你看教育的产品\n",
            "[46:46.800 --> 46:47.600] 也曾经\n",
            "[46:47.800 --> 46:49.520] 他那个时候的AI是\n",
            "[46:49.520 --> 46:50.680] 还是比较传统的\n",
            "[46:50.680 --> 46:51.840] 就是他给你生成一些东西\n",
            "[46:51.840 --> 46:52.440] 你照着念\n",
            "[46:52.440 --> 46:53.680] 然后它识别你语音\n",
            "[46:53.680 --> 46:56.240] 但现在就直接变成了语音跟语音的\n",
            "[46:56.240 --> 46:57.240] 直接的交互\n",
            "[46:57.240 --> 46:58.320] 就是这种东西\n",
            "[46:58.320 --> 47:00.280] 是不是也会带来这种教育类的产品\n",
            "[47:00.280 --> 47:01.320] 或者我们再延展一下\n",
            "[47:01.320 --> 47:02.360] 不光是教育了\n",
            "[47:02.360 --> 47:03.840] 就这种交互的形态\n",
            "[47:03.840 --> 47:04.800] 是不是就是未来\n",
            "[47:04.800 --> 47:06.400] 会是一个比较普遍的形态\n",
            "[47:07.560 --> 47:09.440] 教育类的确没有什么研究\n",
            "[47:09.440 --> 47:10.920] 所以不敢随便乱说\n",
            "[47:11.080 --> 47:12.480] 但是我反而在想一个事情\n",
            "[47:12.600 --> 47:13.640] 就是说因为\n",
            "[47:13.680 --> 47:15.520] Chad GPT是GPT3.5\n",
            "[47:15.520 --> 47:17.600] 一个非常好的一个demo\n",
            "[47:17.680 --> 47:18.920] 他MIT曾经写过篇文章\n",
            "[47:18.920 --> 47:20.960] 讲这个Chad GPT本身的开发的过程\n",
            "[47:21.320 --> 47:22.600] 他们其实是先有模型\n",
            "[47:22.600 --> 47:24.680] 然后再想着用聊天来做这样的demo\n",
            "[47:24.680 --> 47:27.120] 但他似乎又把所有人都带到一个坑里面\n",
            "[47:27.120 --> 47:28.760] 大家都觉得是用来做聊天\n",
            "[47:30.000 --> 47:31.720] 这个我岔开想到这么一个事\n",
            "[47:31.720 --> 47:33.000] 包括现在国内的跟进\n",
            "[47:33.160 --> 47:35.560] 很多都是把它看成是聊天\n",
            "[47:35.800 --> 47:36.880] 但其实你看\n",
            "[47:36.880 --> 47:40.400] 包括他们在讲Chad GPT的API的时候\n",
            "[47:40.400 --> 47:41.680] 他们文档里面会讲说\n",
            "[47:41.680 --> 47:42.520] 他们其实在后面\n",
            "[47:42.520 --> 47:44.840] 还是把它给翻译成print test\n",
            "[47:45.040 --> 47:46.280] 然后提交给模型的\n",
            "[47:46.720 --> 47:48.480] 其实它并不是一个专门为\n",
            "[47:49.040 --> 47:49.560] 为聊天\n",
            "[47:49.560 --> 47:51.520] 甚至可能不是没有聊天优化的一个模型\n",
            "[47:51.600 --> 47:53.280] 所以我觉得这是想到的\n",
            "[47:53.360 --> 47:54.400] 想到的一个点\n",
            "[47:54.600 --> 47:56.360] 但的确可能他们在这个过程当中\n",
            "[47:56.360 --> 47:58.520] 也发现说通过聊天来交互\n",
            "[47:58.760 --> 48:00.840] 和这个大语言模型和这个LM来交互\n",
            "[48:00.840 --> 48:03.760] 是人类一种非常自然的一种形态\n",
            "[48:04.280 --> 48:05.960] 所以也许后面往这个方向去\n",
            "[48:06.240 --> 48:07.240] 再做那些优化\n",
            "[48:08.080 --> 48:10.560] 会不会这是一种叫\n",
            "[48:10.560 --> 48:12.800] 就是比如说generative AI\n",
            "[48:12.920 --> 48:13.160] 对吧\n",
            "[48:13.160 --> 48:15.960] 就生成是AI的那个native中的一种\n",
            "[48:16.240 --> 48:19.680] 就是这种自然语言之间的交互交流\n",
            "[48:20.480 --> 48:23.600] 这算不算就是在这个时代必备的一种\n",
            "[48:25.000 --> 48:28.360] 我觉得就是我的对于我的朋友叫沐瑶\n",
            "[48:28.360 --> 48:29.720] 他在微博上面说的一段话\n",
            "[48:29.720 --> 48:30.840] 我印象非常深\n",
            "[48:31.280 --> 48:34.000] 就是他会认为说GPT或者说所谓的\n",
            "[48:34.000 --> 48:35.160] Find LM\n",
            "[48:35.440 --> 48:38.920] 其实就是结构化的数据的一种自然语言界面\n",
            "[48:39.680 --> 48:43.080] 那我对于这个类比的印象是非常深的\n",
            "[48:43.920 --> 48:46.560] 那比如说像刚刚我们讨论过律师\n",
            "[48:46.880 --> 48:49.160] 其实大家把法律文件理解成一种代码\n",
            "[48:49.520 --> 48:51.160] 那其实律师我们原来雇一个律师\n",
            "[48:51.160 --> 48:52.440] 就是把这个代码解释给你听\n",
            "[48:52.520 --> 48:53.960] 用人话解释给你听\n",
            "[48:54.040 --> 48:55.720] 然后再跟对方的律师去谈判\n",
            "[48:55.720 --> 48:57.760] 然后对方的律师再解释给对方的老板听\n",
            "[48:57.760 --> 48:58.640] 对方的客户听\n",
            "[48:58.640 --> 48:59.880] 然后再找个意见\n",
            "[48:59.880 --> 49:02.880] 然后最后大家用合同或者说用法务文件\n",
            "[49:02.880 --> 49:04.280] 这种代码\n",
            "[49:04.880 --> 49:06.400] 最后来达成某种共识\n",
            "[49:07.480 --> 49:09.880] 那其实GPT就是很擅长干这个事情\n",
            "[49:09.880 --> 49:10.880] 它包括说写程序\n",
            "[49:10.880 --> 49:12.080] 其实本质上也是这样的对吧\n",
            "[49:12.360 --> 49:12.960] 自然语言\n",
            "[49:12.960 --> 49:15.000] 然后把它翻译成机械语言\n",
            "[49:15.320 --> 49:16.240] 机械能懂的语言\n",
            "[49:16.240 --> 49:17.800] 结构化的机械能懂的语言\n",
            "[49:18.280 --> 49:19.360] 然后再把它给翻译回来\n",
            "[49:19.720 --> 49:21.480] 甚至我觉得说个大不敬的\n",
            "[49:21.480 --> 49:23.200] 我觉得大部分产品经理干的事也是这个事\n",
            "[49:24.280 --> 49:26.600] 就是把一种业务需求\n",
            "[49:26.600 --> 49:29.920] 把它翻译成工程师或者说别的代码\n",
            "[49:29.920 --> 49:31.760] 结构化的能够看懂的一种东西\n",
            "[49:32.280 --> 49:34.280] 然后再交给别人再把它翻译成\n",
            "[49:34.280 --> 49:37.120] 可能交给UI把它翻译成设计稿\n",
            "[49:37.400 --> 49:40.480] 设计稿再交给工程师把它翻译成代码\n",
            "[49:41.000 --> 49:42.960] 那其实就是从自然语言往结构化语言\n",
            "[49:42.960 --> 49:45.240] 一步一步的这样的一个翻译\n",
            "[49:45.800 --> 49:46.960] 从这个头像的角度来讲\n",
            "[49:46.960 --> 49:47.920] 那GPT干的事情\n",
            "[49:47.920 --> 49:50.360] 其实就是把各种结构化的数据\n",
            "[49:50.360 --> 49:53.840] 给我们呈现成一种自然语言的界面\n",
            "[49:54.200 --> 49:56.040] 它作为一种服务去呈现\n",
            "[49:56.640 --> 49:59.840] 所以这个角度你会就会能想到很多应用的一些领域\n",
            "[49:59.840 --> 50:02.080] 因为我们其实按照木鸭的看法\n",
            "[50:02.240 --> 50:04.720] 我们现代服务业大部分的工种\n",
            "[50:04.720 --> 50:05.920] 其实都是干这个事情\n",
            "[50:06.200 --> 50:07.560] 律师是干这个事情\n",
            "[50:08.000 --> 50:10.000] 做财务的很多时候也是干这个事情\n",
            "[50:10.000 --> 50:11.880] 我觉得产品经理也是干这个事情\n",
            "[50:11.880 --> 50:13.880] 很多时候其实设计师干的也是这个事情\n",
            "[50:15.280 --> 50:18.160] 所以所有干这个事情的未来\n",
            "[50:18.160 --> 50:21.280] 在大模型时代受到的冲击和挑战都是蛮大的\n",
            "[50:21.480 --> 50:23.920] 因为它直接用自然语言界面把你跳过去\n",
            "[50:24.200 --> 50:25.480] 就说白了就是这么回事\n",
            "[50:25.480 --> 50:28.960] 对你的大部分工作可能就会被取代掉\n",
            "[50:29.560 --> 50:31.560] 我们说好处就是你可以专注在一些\n",
            "[50:31.560 --> 50:35.000] 更需要AI代替不了的一些工作\n",
            "[50:36.000 --> 50:38.880] 我们开场的时候还说产品经理的春天来了\n",
            "[50:39.080 --> 50:41.080] 我现在的群里都一片哀号\n",
            "[50:41.080 --> 50:42.880] 说产品经理的冬天来了\n",
            "[50:43.720 --> 50:45.360] 对我倒想提一个产品\n",
            "[50:45.360 --> 50:46.920] 就评论区里面也有人提了\n",
            "[50:46.920 --> 50:48.240] 就其实不只是教育\n",
            "[50:48.240 --> 50:51.320] 就包括自然语言的交互也都发生了变化\n",
            "[50:52.120 --> 50:54.360] 已经我们可以看到那种数字人\n",
            "[50:54.360 --> 50:58.360] 然后去用他的语音去模仿\n",
            "[50:58.360 --> 50:59.800] 我看他怎么说的\n",
            "[50:59.800 --> 51:03.680] 就是实时的纯音同步数字人跟你聊天\n",
            "[51:03.960 --> 51:09.320] 如果你们去看刘润他发的一些短视频\n",
            "[51:09.800 --> 51:13.560] 他其实已经不是他自己真人在说了\n",
            "[51:13.560 --> 51:15.600] 其实是数字人\n",
            "[51:15.600 --> 51:17.840] 然后也不是他真人在读\n",
            "[51:17.840 --> 51:18.440] 是在模仿\n",
            "[51:18.440 --> 51:21.880] 然后我们看到其实是OpenAI也投了一架\n",
            "[51:21.880 --> 51:23.760] 应该叫TXQV的\n",
            "[51:24.040 --> 51:26.280] 他那东西就是他提供的那些功能\n",
            "[51:26.800 --> 51:30.240] 就有点像小宇宙剪辑一样\n",
            "[51:30.240 --> 51:31.200] 或者一堆的剪辑一样\n",
            "[51:31.200 --> 51:33.160] 就帮你去一些口品\n",
            "[51:33.160 --> 51:35.720] 然后去因为我自己在做播客\n",
            "[51:35.960 --> 51:36.240] 对吧\n",
            "[51:36.240 --> 51:38.440] 去除一些气口与其词那些东西\n",
            "[51:38.440 --> 51:40.600] 就把没有东西给你集中处理掉\n",
            "[51:40.600 --> 51:43.560] 然后可以去做AI的绿幕处理\n",
            "[51:43.560 --> 51:44.880] 就比如说苹果手机\n",
            "[51:44.880 --> 51:47.400] 现在可以帮大家自动居中续化背影\n",
            "[51:47.400 --> 51:48.240] 就是拍视频的时候\n",
            "[51:48.240 --> 51:48.880] 他也可以\n",
            "[51:48.880 --> 51:52.000] 就是类似于像这种声音的克隆\n",
            "[51:52.160 --> 51:52.880] 生成AI\n",
            "[51:53.360 --> 51:55.400] 然后根据文案来配声音\n",
            "[51:55.400 --> 51:57.040] 这个其实剪音也OK\n",
            "[51:57.040 --> 51:58.520] 就是说到这里\n",
            "[51:58.520 --> 51:59.680] 我感觉就是整体的\n",
            "[51:59.960 --> 52:02.200] 类似于就把美图剪音这些东西\n",
            "[52:02.200 --> 52:04.560] 就是把它加上这种能力之后\n",
            "[52:04.560 --> 52:05.960] 让他自己操作\n",
            "[52:06.400 --> 52:08.600] 这种的感受是更强一点的\n",
            "[52:09.200 --> 52:10.960] 这个东西我一直特别想用\n",
            "[52:10.960 --> 52:12.320] 因为如果有这个东西之后\n",
            "[52:12.520 --> 52:15.280] 那以后咱们比如说这个视频\n",
            "[52:15.280 --> 52:16.240] 完了之后\n",
            "[52:16.520 --> 52:18.600] 那个切条播客\n",
            "[52:18.800 --> 52:20.440] 都非常顺的生成\n",
            "[52:20.720 --> 52:20.960] 对\n",
            "[52:20.960 --> 52:23.240] 那就不需要再花好长时间\n",
            "[52:23.240 --> 52:26.040] 来去精条这些的东西\n",
            "[52:26.040 --> 52:26.640] 对\n",
            "[52:27.360 --> 52:28.240] 你试用过吗\n",
            "[52:28.240 --> 52:29.560] 或者说你怎么看\n",
            "[52:29.880 --> 52:30.560] 这类产品\n",
            "[52:30.560 --> 52:33.360] 它可能会让哪些用户\n",
            "[52:33.360 --> 52:34.600] 或者说哪些人\n",
            "[52:34.600 --> 52:36.640] 哪种内容在这里面受益呢\n",
            "[52:38.200 --> 52:39.920] 我觉得第一个就刚才讲\n",
            "[52:40.920 --> 52:42.920] 我觉得产品经理反而春天到了\n",
            "[52:43.040 --> 52:43.600] 当然了\n",
            "[52:43.600 --> 52:46.160] 就是跟所有行业面临的问题是一样的\n",
            "[52:46.280 --> 52:47.600] 所有的行业\n",
            "[52:47.600 --> 52:49.720] 就初阶产品经理肯定是\n",
            "[52:49.960 --> 52:51.240] 会爱好一片的\n",
            "[52:51.240 --> 52:52.720] 因为你的本质的技能\n",
            "[52:52.720 --> 52:53.880] 就是把几句需求\n",
            "[52:53.880 --> 52:55.160] 或者转换成一个界面\n",
            "[52:55.600 --> 52:56.040] 对吧\n",
            "[52:56.040 --> 52:59.600] 这里其实是产品经理很大的部分工作\n",
            "[52:59.920 --> 53:02.000] 但实际上这个工作价值是不大的\n",
            "[53:02.400 --> 53:03.560] 他就是熟练工作\n",
            "[53:04.240 --> 53:04.760] 对吧\n",
            "[53:04.840 --> 53:06.360] 我觉得产品经理真正的意义\n",
            "[53:06.360 --> 53:07.960] 是找到用户场景用户需求\n",
            "[53:07.960 --> 53:09.280] 然后去设计这个产品\n",
            "[53:09.280 --> 53:10.320] 然后怎么把这产品\n",
            "[53:10.320 --> 53:13.280] 所以这时候他反而能够使得\n",
            "[53:13.360 --> 53:14.400] 高阶的产品经理\n",
            "[53:14.400 --> 53:16.440] 他更快的去实现他的产品原型\n",
            "[53:16.440 --> 53:17.560] 和这个效果\n",
            "[53:17.840 --> 53:20.040] 因为他基础的这个基础框架\n",
            "[53:20.040 --> 53:21.440] 已经特别简单了\n",
            "[53:22.040 --> 53:23.440] 对再回到刚讲教育的\n",
            "[53:23.440 --> 53:24.360] 我挺感兴趣的\n",
            "[53:24.360 --> 53:26.120] 因为我认为教育也是变革的\n",
            "[53:26.120 --> 53:28.400] 就这次我就是打牌神仙\n",
            "[53:28.400 --> 53:29.960] 贪吃蛇的这个过程\n",
            "[53:30.280 --> 53:31.520] 就让我突然理解了\n",
            "[53:31.520 --> 53:33.640] 就是所谓传道授业解惑\n",
            "[53:33.640 --> 53:34.440] 就是一对一的\n",
            "[53:34.440 --> 53:35.960] 有个老师经常你去问他\n",
            "[53:35.960 --> 53:36.800] 或者他问你\n",
            "[53:36.920 --> 53:38.400] 这个成长是最快的\n",
            "[53:38.720 --> 53:39.720] 到了后来是没办法\n",
            "[53:39.720 --> 53:41.280] 让你读一本大块头的书\n",
            "[53:41.280 --> 53:42.680] 你自己去总结归纳\n",
            "[53:42.680 --> 53:42.960] 对吧\n",
            "[53:42.960 --> 53:44.600] 其实你在这个过程中\n",
            "[53:44.800 --> 53:46.320] 你慢慢就知道了\n",
            "[53:46.680 --> 53:49.480] 等我把这个东西弄出来几天时间\n",
            "[53:49.720 --> 53:51.920] 越狱时间把这个程序环境搭出来\n",
            "[53:51.920 --> 53:53.520] 对苹果的界面\n",
            "[53:53.520 --> 53:55.320] 那个Python的那个虚拟环境\n",
            "[53:55.320 --> 53:56.040] 编程界面\n",
            "[53:56.040 --> 53:57.600] 包括Python语法我也会了\n",
            "[53:57.600 --> 53:59.000] 但我不需要一行一行去写\n",
            "[53:59.000 --> 53:59.760] Hello world\n",
            "[53:59.760 --> 54:01.400] 然后每个累的半死\n",
            "[54:01.400 --> 54:03.360] 就改一个缩近\n",
            "[54:04.000 --> 54:04.240] 对吧\n",
            "[54:04.240 --> 54:06.840] 所以是极快的能够学到东西的\n",
            "[54:07.160 --> 54:09.240] 所以回到那个就是刚讲的\n",
            "[54:09.240 --> 54:10.600] 那个结构化语言的\n",
            "[54:10.600 --> 54:12.200] 自然语言的表达\n",
            "[54:12.520 --> 54:14.640] 所以我认为这个交互革命\n",
            "[54:14.640 --> 54:16.960] 这一场可能来的比大家想象的要快得多\n",
            "[54:17.480 --> 54:19.040] 然后说到数字人那个叛乱\n",
            "[54:19.040 --> 54:20.440] 我正好之所以插一句\n",
            "[54:20.440 --> 54:21.680] 就是我灭头了一个\n",
            "[54:21.680 --> 54:23.400] 这个刚正在做这个\n",
            "[54:23.600 --> 54:26.200] 因为我认为今天这些技术都已经\n",
            "[54:26.400 --> 54:27.760] 就尤其下的GPD吧\n",
            "[54:27.760 --> 54:29.760] 应该是补上了最大的一块短板\n",
            "[54:30.080 --> 54:31.280] 这个短板是在过去\n",
            "[54:31.280 --> 54:32.440] 我做了六年机器人里面\n",
            "[54:32.440 --> 54:33.480] 特别痛苦的一件事\n",
            "[54:33.480 --> 54:35.640] 就是他不理解语意\n",
            "[54:36.080 --> 54:37.240] 因为他有点像\n",
            "[54:37.520 --> 54:38.720] 图像识别出来之前\n",
            "[54:38.720 --> 54:39.760] 也有做图像识别的\n",
            "[54:39.760 --> 54:40.880] 也有做人脸识别的\n",
            "[54:40.960 --> 54:42.240] 他不是识别不了人脸\n",
            "[54:42.240 --> 54:43.760] 他大概识别60%\n",
            "[54:44.400 --> 54:46.640] 但是60%用户呢就没法用\n",
            "[54:47.360 --> 54:49.640] 就他没有进用户的那个及格线\n",
            "[54:49.640 --> 54:51.120] 所以这个东西永远没有产品化\n",
            "[54:51.120 --> 54:53.960] 永远是大公司在做科研院所在做\n",
            "[54:54.200 --> 54:55.560] 只是做探索性研究\n",
            "[54:55.760 --> 54:57.520] 等到这个神奇网络一出来\n",
            "[54:57.520 --> 54:59.800] 过了90%这条线立刻就铺开了\n",
            "[55:00.480 --> 55:02.560] 对吧这次GPD这个一出来\n",
            "[55:02.840 --> 55:04.080] 对这个语意的理解\n",
            "[55:04.080 --> 55:05.640] 我觉得都不止90%这条线了\n",
            "[55:05.640 --> 55:06.920] 还有更高的时候\n",
            "[55:07.600 --> 55:09.240] 所以的确应该搞一个\n",
            "[55:09.280 --> 55:11.400] 所有做内容的人都应该搞一个\n",
            "[55:11.400 --> 55:13.520] 这个自己的素质的完整人\n",
            "[55:14.120 --> 55:15.240] 极大的解约精力\n",
            "[55:15.240 --> 55:17.720] 而且体验上已经差不了太多了\n",
            "[55:17.960 --> 55:19.720] 而且比你兴奋\n",
            "[55:19.720 --> 55:21.840] 哎呀 甩了\n",
            "[55:21.840 --> 55:25.520] 对我们好能继续偷懒是吧\n",
            "[55:25.520 --> 55:28.120] 或者说我们得到了真正的支持\n",
            "[55:28.360 --> 55:31.080] 助理不是在给苏生这样的老板配的了\n",
            "[55:31.080 --> 55:32.600] 我们每个人都要有的啊\n",
            "[55:32.920 --> 55:35.680] 对对对我们在内部提的口号\n",
            "[55:35.680 --> 55:37.760] 就是每个人都要学会用五个助理\n",
            "[55:38.120 --> 55:40.360] 不会用这个的你们就应该被淘汰掉\n",
            "[55:40.360 --> 55:41.800] 因为这个没有办法\n",
            "[55:41.800 --> 55:43.360] 就是以后整个社会都\n",
            "[55:45.240 --> 55:47.400] 这个我可能也答的比较算了\n",
            "[55:47.400 --> 55:49.280] 可能也不是特指GPD4\n",
            "[55:49.280 --> 55:51.000] Discree我用的比较早\n",
            "[55:51.000 --> 55:53.120] 因为最早是因为它是Google的创始人做的\n",
            "[55:53.120 --> 55:54.680] 所以很早就用过\n",
            "[55:55.000 --> 55:56.920] 坦白讲可能还没有看出\n",
            "[55:56.920 --> 55:58.480] 刚才最近的这个press release\n",
            "[55:58.480 --> 55:59.280] 我没有仔细看\n",
            "[55:59.800 --> 56:02.600] 没有看出它跟LM的关系在什么地方\n",
            "[56:02.600 --> 56:03.960] 我最初的印象就是说\n",
            "[56:03.960 --> 56:06.520] 他很聪明的是把音频转成了文本\n",
            "[56:06.520 --> 56:07.880] 然后也通过编辑文本\n",
            "[56:08.240 --> 56:10.120] 就能来编辑音频\n",
            "[56:10.400 --> 56:11.760] 但是泛泛的讲的\n",
            "[56:11.760 --> 56:12.920] 比如说它里面有一些\n",
            "[56:12.920 --> 56:16.720] 那些生神插图生神视频的关键证的一些demo\n",
            "[56:17.200 --> 56:18.960] 你好像就会泛泛的想会觉得\n",
            "[56:18.960 --> 56:20.200] 其实做播客\n",
            "[56:20.560 --> 56:21.480] 虽然我自己不做\n",
            "[56:21.480 --> 56:24.000] 判断可能也做播客的方法跟别人也不太一样\n",
            "[56:24.640 --> 56:26.000] 但大家可能有一个概念是说\n",
            "[56:26.000 --> 56:27.160] 就是你录一个小时\n",
            "[56:27.160 --> 56:28.880] 可能要剪4个小时5个小时\n",
            "[56:29.280 --> 56:31.480] 已经有大量的工作是在这种\n",
            "[56:31.480 --> 56:33.160] 你会觉得很重复的\n",
            "[56:33.960 --> 56:36.920] 琐碎的很体力活的一些事情上\n",
            "[56:37.280 --> 56:39.720] 我觉得好像今天的大部分的创作的工作\n",
            "[56:39.720 --> 56:40.640] 其实都是这样的\n",
            "[56:41.120 --> 56:44.600] 我那天跟另外的一个杂志的主编吃饭\n",
            "[56:44.960 --> 56:47.040] 他其实说了一句话让我会觉得非常意外\n",
            "[56:47.640 --> 56:49.880] 他说其实所有的人都害怕写文字\n",
            "[56:50.120 --> 56:51.240] 所有的人都害怕写文章\n",
            "[56:51.520 --> 56:53.440] 写文章对所有人来讲都是痛苦的事情\n",
            "[56:53.440 --> 56:56.920] 即使是他们是专业的编辑还是和记者\n",
            "[56:57.120 --> 56:59.680] 尤其是喷浪\n",
            "[56:59.680 --> 57:01.120] 所以搞直播了\n",
            "[57:03.160 --> 57:04.720] 所以其实像GPT这种\n",
            "[57:04.720 --> 57:06.760] 包括说我们也会看到像notion\n",
            "[57:06.880 --> 57:07.960] 我现在经常也用它\n",
            "[57:07.960 --> 57:09.320] 比如说写产品文档\n",
            "[57:09.480 --> 57:10.880] 可能我真的就给他几个要点\n",
            "[57:11.160 --> 57:14.160] 然后他先展开成一堆可能废话很多\n",
            "[57:14.480 --> 57:16.560] 可能起码10篇文章是一个完整的文档\n",
            "[57:17.040 --> 57:17.640] 这样的一个东西\n",
            "[57:17.760 --> 57:20.920] 你其实至少是说你让这个事情变得没有那么害怕\n",
            "[57:20.920 --> 57:22.280] 你有一个有个起点\n",
            "[57:23.040 --> 57:25.200] 包括GPT4我最近两天在试用\n",
            "[57:25.200 --> 57:27.600] 当我没有对比过跟GPT3.5的一个效果\n",
            "[57:27.960 --> 57:30.880] 我就在我的笔记本里面随机的找几条笔记出来\n",
            "[57:30.880 --> 57:32.760] 但这几条笔记还是有一点关联的\n",
            "[57:33.160 --> 57:35.320] 可能是某一个话题或者同样的图像\n",
            "[57:35.800 --> 57:38.200] 然后我说你能不能把这几条笔记给你\n",
            "[57:38.280 --> 57:39.520] 你能把它串成一篇文章\n",
            "[57:40.080 --> 57:41.040] 那我一般拿到的效果\n",
            "[57:41.040 --> 57:41.800] 虽然来讲的话\n",
            "[57:41.800 --> 57:44.160] 可能你会觉得它是一本正经的在胡说八道\n",
            "[57:44.160 --> 57:45.520] 但起码是一篇能看的东西\n",
            "[57:45.960 --> 57:48.840] 那我觉得他把你创作的一个门槛很大的一部分\n",
            "[57:49.240 --> 57:52.560] 把这种硬的工作量给降低了非常非常的多\n",
            "[57:52.880 --> 57:53.920] 那所以我觉得他\n",
            "[57:54.440 --> 57:55.280] 我们去想象说\n",
            "[57:55.280 --> 57:57.520] 那如果一个人他不需要那么痛苦的去写作\n",
            "[57:57.520 --> 58:02.320] 他甚至不需要从小学一年级到高中学那么多年的语文\n",
            "[58:02.360 --> 58:04.680] 他也可以很自如的来表达自己的思想\n",
            "[58:05.160 --> 58:06.920] 那世界我觉得还是会发生挺多的\n",
            "[58:06.920 --> 58:07.760] 挺多的变化的\n",
            "[58:07.760 --> 58:08.920] 虽然现在说不出是什么\n",
            "[58:09.600 --> 58:11.840] 你可以很结构化的来表达你的思想\n",
            "[58:11.840 --> 58:14.040] 把你的思想很充分的表达给别人看\n",
            "[58:14.400 --> 58:17.720] 而不需要掌握写作这样的一个技能\n",
            "[58:17.720 --> 58:19.200] 写作真的是个很难的一个技能\n",
            "[58:20.640 --> 58:21.920] 我挺认同的\n",
            "[58:21.920 --> 58:24.920] 就是我跟潘乱其实都是写字的人\n",
            "[58:24.920 --> 58:26.040] 我到今天我还在写\n",
            "[58:26.280 --> 58:30.440] 潘乱已经因为找到了直播和播客的方式\n",
            "[58:30.440 --> 58:31.720] 他可以不怎么写了\n",
            "[58:32.000 --> 58:33.960] 但是我确实觉得就是即便\n",
            "[58:33.960 --> 58:35.800] 就是你很享受写完的感觉\n",
            "[58:36.120 --> 58:37.880] 但是写的过程都是超级痛苦的\n",
            "[58:38.280 --> 58:41.920] 所以如果有人就是把这个China GPT\n",
            "[58:41.920 --> 58:44.240] 他能够在这个基础上帮你生成一个底\n",
            "[58:44.240 --> 58:45.000] 然后你去改\n",
            "[58:45.000 --> 58:45.360] 对吧\n",
            "[58:45.360 --> 58:48.760] 就是改的成本是比写的成本低很多的\n",
            "[58:48.760 --> 58:49.320] 对吧\n",
            "[58:49.320 --> 58:51.880] 本质上我觉得就是这个对每个人\n",
            "[58:51.880 --> 58:53.760] 就是你看Simon Altman\n",
            "[58:53.760 --> 58:55.560] 我为什么觉得他这个人很厉害\n",
            "[58:56.040 --> 58:57.520] 包括OpenAI能做成\n",
            "[58:57.800 --> 58:59.120] 就他当年就是在讲\n",
            "[58:59.120 --> 59:00.600] 就是用这个OpenAI很重要一点\n",
            "[59:00.600 --> 59:03.000] 要解决所谓的资本主义的一些问题\n",
            "[59:03.600 --> 59:05.040] 就是你怎么普惠\n",
            "[59:05.040 --> 59:07.640] 然后你把这个能力更多人可以用\n",
            "[59:07.640 --> 59:09.680] 所以我当我看到这个China GPT\n",
            "[59:09.680 --> 59:10.840] 所有人都能用的时候\n",
            "[59:10.840 --> 59:13.760] 你就发现所有人本质上都能有个初级助理\n",
            "[59:13.760 --> 59:16.360] 就是看你是不是用心的在用的\n",
            "[59:16.640 --> 59:17.800] 这一点还没有到位\n",
            "[59:17.800 --> 59:20.360] 但我相信未来会有各种形态的产品\n",
            "[59:20.360 --> 59:21.800] 让大家更好用\n",
            "[59:21.800 --> 59:23.320] 用到这个底层的能力\n",
            "[59:23.320 --> 59:24.960] 然后就是像傅盛说的\n",
            "[59:24.960 --> 59:26.320] 就每个人可能5个助理\n",
            "[59:26.320 --> 59:26.640] 对吧\n",
            "[59:26.640 --> 59:29.520] 或者说一个助理有50种能力\n",
            "[59:29.640 --> 59:30.800] 这都是有可能实现\n",
            "[59:31.240 --> 59:32.840] 这个还是让人印象很深的\n",
            "[59:33.400 --> 59:35.200] 说到这我就再延展一个产品\n",
            "[59:35.680 --> 59:36.600] 最近一段时间\n",
            "[59:36.600 --> 59:38.440] 我跟这个李志飞\n",
            "[59:38.720 --> 59:40.400] 我们出差的时候有几天\n",
            "[59:40.400 --> 59:42.280] 我看他天天抱着Notion\n",
            "[59:42.680 --> 59:43.760] 就已经成为了\n",
            "[59:43.760 --> 59:45.600] 我觉得那个就是他手里的宝贝\n",
            "[59:46.000 --> 59:48.840] 他有点啥事他都跟Notion上去玩一玩\n",
            "[59:49.120 --> 59:49.880] 然后去问一问\n",
            "[59:49.880 --> 59:50.920] 然后经常跟我说\n",
            "[59:50.920 --> 59:52.000] 你看这个回答的\n",
            "[59:52.000 --> 59:52.840] 这个怎么怎么着\n",
            "[59:53.200 --> 59:53.880] 就你能理解\n",
            "[59:53.880 --> 59:56.040] 就他为什么对大模型这件事很兴奋\n",
            "[59:56.400 --> 59:57.720] 他包括运用Notion\n",
            "[59:57.720 --> 01:00:00.080] 已经成了他一个自己的小助理一样\n",
            "[01:00:00.360 --> 01:00:01.960] 然后他并且乐此不疲\n",
            "[01:00:02.240 --> 01:00:04.000] 我不知道各位用的感觉怎么样\n",
            "[01:00:04.000 --> 01:00:04.800] 用Notion\n",
            "[01:00:04.800 --> 01:00:06.760] 因为本身跟你的工作又有关系\n",
            "[01:00:07.080 --> 01:00:08.280] 又能融入到这里面\n",
            "[01:00:08.560 --> 01:00:10.720] 有没有人已经在这里面体验到\n",
            "[01:00:10.920 --> 01:00:12.760] 运用这种方式进入你的工作流\n",
            "[01:00:13.000 --> 01:00:14.040] 在起作用的方式\n",
            "[01:00:14.320 --> 01:00:15.160] 潘岚有没有用过\n",
            "[01:00:15.160 --> 01:00:16.040] 傅盛有没有用过\n",
            "[01:00:16.320 --> 01:00:17.240] 用过的可以说一说\n",
            "[01:00:17.600 --> 01:00:18.160] 我没用过\n",
            "[01:00:18.160 --> 01:00:20.320] 然后我特别期待飞叔把他加进去\n",
            "[01:00:20.320 --> 01:00:22.000] 然后就是飞叔把大模型加进去\n",
            "[01:00:22.000 --> 01:00:23.280] 因为我们刚才聊那个\n",
            "[01:00:23.280 --> 01:00:26.320] 譬如说Disc Repeat\n",
            "[01:00:26.920 --> 01:00:28.120] 你其实如果看的话\n",
            "[01:00:28.120 --> 01:00:29.760] 它其实就特别像飞叔妙计\n",
            "[01:00:29.760 --> 01:00:31.240] 然后再剪影就是一些功能\n",
            "[01:00:31.240 --> 01:00:33.360] 然后我其实并没有在里面看到\n",
            "[01:00:33.360 --> 01:00:35.160] 多生的大模型的影子\n",
            "[01:00:35.160 --> 01:00:37.320] 就是跟刚才俊宇的感受是类似的\n",
            "[01:00:37.560 --> 01:00:39.680] 但是如果是在这样的产品里面\n",
            "[01:00:39.680 --> 01:00:41.520] 其实就是因为我在飞叔文档里面\n",
            "[01:00:41.520 --> 01:00:42.360] 写的东西足够多\n",
            "[01:00:42.560 --> 01:00:43.920] 就是沉淀的知识足够多\n",
            "[01:00:43.920 --> 01:00:46.120] 就是我的数字的大脑可能就是\n",
            "[01:00:46.120 --> 01:00:47.280] 就是对于行业的\n",
            "[01:00:47.560 --> 01:00:48.360] 可能就有一半\n",
            "[01:00:48.360 --> 01:00:50.040] 就全部都藏在飞叔里面了\n",
            "[01:00:50.360 --> 01:00:50.640] 对\n",
            "[01:00:50.640 --> 01:00:52.600] 我特别希望飞叔赶快\n",
            "[01:00:52.840 --> 01:00:53.880] 这些事情得赶快\n",
            "[01:00:53.880 --> 01:00:54.400] 对\n",
            "[01:00:55.400 --> 01:00:57.480] 感觉今晚上你就是给字节\n",
            "[01:00:57.480 --> 01:00:58.800] 一直在发作业\n",
            "[01:00:59.320 --> 01:01:01.520] 刚才大力教育要努力\n",
            "[01:01:01.520 --> 01:01:03.200] 现在要飞叔叫加油\n",
            "[01:01:03.560 --> 01:01:06.640] 攀岚一直在给字节系加作业\n",
            "[01:01:07.320 --> 01:01:10.080] 傅胜有没有用Notion有什么体会吗\n",
            "[01:01:11.240 --> 01:01:12.240] 我用的不多\n",
            "[01:01:12.240 --> 01:01:13.960] 我也就那几天用了一下\n",
            "[01:01:13.960 --> 01:01:16.520] 他我觉得他加强功能和\n",
            "[01:01:17.520 --> 01:01:20.000] 他大概是因为我用圈基地用太多了\n",
            "[01:01:20.000 --> 01:01:21.800] 所以我倒没觉得太惊艳\n",
            "[01:01:21.800 --> 01:01:23.240] 反而我觉得做的\n",
            "[01:01:23.280 --> 01:01:24.920] 我觉得在扩展上其实还有很多点\n",
            "[01:01:24.920 --> 01:01:25.960] 就可以做的\n",
            "[01:01:26.200 --> 01:01:28.280] 就他没有做出足够的特色\n",
            "[01:01:28.720 --> 01:01:30.520] 就是过于简洁了\n",
            "[01:01:30.520 --> 01:01:32.920] 如果你打开那个界面\n",
            "[01:01:33.200 --> 01:01:35.840] 贴段文字让会员帮你去认色什么\n",
            "[01:01:35.840 --> 01:01:36.640] 也可以做\n",
            "[01:01:37.000 --> 01:01:39.120] 就是现在其实也就是这个行业的\n",
            "[01:01:39.120 --> 01:01:40.280] 就因为这东西太新了\n",
            "[01:01:40.280 --> 01:01:42.280] 所以大家能加上去就有很多用户\n",
            "[01:01:42.680 --> 01:01:43.440] 就觉得很好\n",
            "[01:01:43.440 --> 01:01:46.080] 但事实上我觉得能做细的地方还挺多的\n",
            "[01:01:46.640 --> 01:01:48.040] 再给我支持下潘乐\n",
            "[01:01:48.040 --> 01:01:49.040] 就是我觉得\n",
            "[01:01:49.640 --> 01:01:51.480] 国内能做大模型的第一是百度\n",
            "[01:01:51.480 --> 01:01:52.880] 第二应该就是字节了\n",
            "[01:01:53.200 --> 01:01:55.000] 他们俩讲是最有希望出那种\n",
            "[01:01:56.120 --> 01:01:59.280] 理解今天我回头到时候说一下了\n",
            "[01:01:59.280 --> 01:02:01.640] 今天晚上富盛也给字节加作业了\n",
            "[01:02:01.640 --> 01:02:04.240] 说这个喊你们出来交作业是吧\n",
            "[01:02:04.240 --> 01:02:05.880] 就是基本就是这个感觉\n",
            "[01:02:05.880 --> 01:02:07.240] 然后那个军玉怎么看\n",
            "[01:02:07.240 --> 01:02:09.160] 你Notion应该也用的比较多\n",
            "[01:02:09.280 --> 01:02:10.080] 你对Notion\n",
            "[01:02:10.080 --> 01:02:12.480] 包括对于他未来的期待和想象吗\n",
            "[01:02:13.360 --> 01:02:14.200] 我用的还蛮多的\n",
            "[01:02:14.200 --> 01:02:17.000] 然后但我也同意富盛老师的看法\n",
            "[01:02:17.480 --> 01:02:20.840] 就是他其实今天在AI的整个上面比较薄\n",
            "[01:02:21.640 --> 01:02:22.440] 本质上面来讲\n",
            "[01:02:22.440 --> 01:02:25.560] 我觉得他就是把GPT的API批发了一下\n",
            "[01:02:26.120 --> 01:02:27.920] 我还甚至算了一下他的价格什么\n",
            "[01:02:27.920 --> 01:02:31.320] 其实跟他还是比你买GPT要划算一点\n",
            "[01:02:31.840 --> 01:02:32.800] 但是其实对我来讲的话\n",
            "[01:02:32.800 --> 01:02:34.520] 因为我本来文档就在上面\n",
            "[01:02:34.520 --> 01:02:36.520] 所以对我来讲第一是省掉了\n",
            "[01:02:36.520 --> 01:02:39.520] 把它复制粘贴到在GPT里面的第一步\n",
            "[01:02:39.800 --> 01:02:41.760] 第二步是写一个简单的promote\n",
            "[01:02:42.440 --> 01:02:44.240] 其实相当于是把这两步给省掉了\n",
            "[01:02:44.360 --> 01:02:45.160] 它其实就是个\n",
            "[01:02:45.560 --> 01:02:46.920] 我们传统的互联网的说法\n",
            "[01:02:46.920 --> 01:02:47.560] 它就是个入口\n",
            "[01:02:48.120 --> 01:02:50.720] 它其实就是GPT的一个入口的一个渠道\n",
            "[01:02:51.120 --> 01:02:52.600] 它在上面今天做的增值\n",
            "[01:02:53.640 --> 01:02:54.840] 其实我觉得还是蛮少的\n",
            "[01:02:55.600 --> 01:02:57.120] 包括其实除了Notion以外\n",
            "[01:02:57.600 --> 01:02:58.800] 现在有很多笔记产品\n",
            "[01:02:58.800 --> 01:03:00.320] 其实都加了一模一样的功能\n",
            "[01:03:01.000 --> 01:03:02.880] 甚至这几个用法其实都挺像的\n",
            "[01:03:03.400 --> 01:03:04.880] 包括了craft\n",
            "[01:03:05.600 --> 01:03:07.560] 包括了国内的Qbox\n",
            "[01:03:07.560 --> 01:03:10.280] 应该前两周也加了类似的功能\n",
            "[01:03:10.960 --> 01:03:13.440] 当我日常用的比较多的改写文章\n",
            "[01:03:13.880 --> 01:03:14.560] 总结\n",
            "[01:03:15.200 --> 01:03:17.400] 会议记录提取突度等等\n",
            "[01:03:17.840 --> 01:03:19.400] 其实还是蛮实用的\n",
            "[01:03:19.440 --> 01:03:21.520] 能够整合到整个的工作流里面来\n",
            "[01:03:21.920 --> 01:03:23.640] 但大家真的今天做的都还是蛮浅的\n",
            "[01:03:23.640 --> 01:03:25.600] 包括是说有个产品叫MIM\n",
            "[01:03:25.600 --> 01:03:26.920] 就是MIM.AI\n",
            "[01:03:26.920 --> 01:03:30.080] 号称是说用GPT来整理个人知识库\n",
            "[01:03:30.600 --> 01:03:31.320] 但本质上面来讲\n",
            "[01:03:31.320 --> 01:03:32.920] 他们其实都不锁定个人知识库\n",
            "[01:03:32.920 --> 01:03:34.720] 包括所有AI今天做的事情\n",
            "[01:03:34.720 --> 01:03:37.840] 它跟你的企业的知识库一点关系都没有\n",
            "[01:03:38.600 --> 01:03:40.840] 因为你知道GPT的API是长什么样\n",
            "[01:03:40.840 --> 01:03:41.880] 你也大概能理解它\n",
            "[01:03:42.240 --> 01:03:43.160] 其实做的事情很浅\n",
            "[01:03:43.160 --> 01:03:44.160] 它还没有去付费\n",
            "[01:03:44.160 --> 01:03:46.400] 去更高级的API\n",
            "[01:03:46.400 --> 01:03:48.240] 它无非就是把你当前的页面发给它\n",
            "[01:03:48.680 --> 01:03:49.840] 所以这是他今天的写作\n",
            "[01:03:49.960 --> 01:03:51.200] 我觉得今天还是一个\n",
            "[01:03:51.640 --> 01:03:53.480] 更像是黑媒的一个时代\n",
            "[01:03:54.240 --> 01:03:56.800] 你会觉得他写出来的东西虽然是能看懂\n",
            "[01:03:56.800 --> 01:03:57.920] 但是非常耍人无味\n",
            "[01:03:58.400 --> 01:04:00.160] 非常的平淡\n",
            "[01:04:00.680 --> 01:04:03.160] 用的词有可能很多你不喜欢的词\n",
            "[01:04:03.160 --> 01:04:06.240] 他没有办法来理解你想要的东西\n",
            "[01:04:06.240 --> 01:04:08.160] 你想要的口味\n",
            "[01:04:08.160 --> 01:04:09.480] 但你可以用一些简单的promote\n",
            "[01:04:09.480 --> 01:04:11.360] 去给他一些很具体的一些要求\n",
            "[01:04:11.360 --> 01:04:12.160] 但这个就很累\n",
            "[01:04:12.760 --> 01:04:14.520] 他还没有办法说更自动的来去理解\n",
            "[01:04:14.520 --> 01:04:15.320] 说来学习\n",
            "[01:04:15.320 --> 01:04:17.720] 其实说我过去写作的风格是什么样的\n",
            "[01:04:18.200 --> 01:04:21.640] 我喜欢什么样的摘要的方式\n",
            "[01:04:22.280 --> 01:04:24.720] 我觉得这些都是在今天的基础上面\n",
            "[01:04:24.720 --> 01:04:25.520] 比较容易想象\n",
            "[01:04:25.520 --> 01:04:27.920] 包括大家说非输加上这个东西\n",
            "[01:04:28.400 --> 01:04:29.560] 我觉得他买家比较容易想象\n",
            "[01:04:29.560 --> 01:04:32.320] 说非输加上以后能做到什么样子\n",
            "[01:04:32.880 --> 01:04:34.080] 就至少说跟notion今天平\n",
            "[01:04:34.080 --> 01:04:35.160] 其实太容易想象到\n",
            "[01:04:35.600 --> 01:04:37.160] 大家进一步的再去想的话\n",
            "[01:04:37.520 --> 01:04:38.560] 那还得再把它做出来\n",
            "[01:04:38.920 --> 01:04:40.080] 比notion要更进一步\n",
            "[01:04:40.080 --> 01:04:42.400] 所以notion今天我觉得在AI的使用上面\n",
            "[01:04:42.400 --> 01:04:43.520] 其实还是非常浅\n",
            "[01:04:44.160 --> 01:04:46.800] 只是把GPT的API做了一个\n",
            "[01:04:47.440 --> 01:04:48.520] 做了个零售算是\n",
            "[01:04:49.360 --> 01:04:53.800] 对我多期待在我们的直播间里\n",
            "[01:04:53.800 --> 01:04:56.000] 有非输的同学跳到这说\n",
            "[01:04:56.000 --> 01:04:57.360] 再做了\n",
            "[01:04:57.360 --> 01:04:58.560] 快来了\n",
            "[01:04:59.600 --> 01:05:01.400] 就是我们看起来大家都很期待\n",
            "[01:05:01.640 --> 01:05:04.400] 非输未来在这上面要加上这个功能\n",
            "[01:05:04.800 --> 01:05:07.560] 对但notion那个界面和交互也反正也挺奇怪的\n",
            "[01:05:08.240 --> 01:05:10.760] 我觉得跟GPT现在的限制会有些关系\n",
            "[01:05:10.760 --> 01:05:12.360] 比如说我要让他改天文章\n",
            "[01:05:12.360 --> 01:05:15.200] 其实要等他一个字一个字的重新蹦一遍\n",
            "[01:05:15.560 --> 01:05:16.480] 这实在太痛苦了\n",
            "[01:05:17.400 --> 01:05:18.840] 你知道GPTAPI就是这样的\n",
            "[01:05:20.200 --> 01:05:22.720] 等下我看我这直播间里有人突然蹦出来说\n",
            "[01:05:22.720 --> 01:05:23.400] 再做了\n",
            "[01:05:23.400 --> 01:05:24.680] 当然我不敢确认\n",
            "[01:05:24.920 --> 01:05:26.400] 你是不是非输的团队\n",
            "[01:05:26.960 --> 01:05:28.320] 非输的产品在加班\n",
            "[01:05:28.680 --> 01:05:29.640] 今天评审了\n",
            "[01:05:30.400 --> 01:05:32.000] 我榨出好多信息\n",
            "[01:05:32.280 --> 01:05:32.960] 你们好厉害\n",
            "[01:05:34.280 --> 01:05:35.160] 期待\n",
            "[01:05:35.560 --> 01:05:36.800] 已经列在OK2里了\n",
            "[01:05:37.760 --> 01:05:39.560] 这个信息全出来了\n",
            "[01:05:39.920 --> 01:05:40.520] 好好好\n",
            "[01:05:40.960 --> 01:05:42.520] 我相信就是这么卷的团队\n",
            "[01:05:42.520 --> 01:05:44.160] 不可能错过这种事情的\n",
            "[01:05:44.360 --> 01:05:47.160] 他们都会把精力放在一个定时发送的\n",
            "[01:05:47.160 --> 01:05:48.640] 这样的一个小小功能设计\n",
            "[01:05:48.640 --> 01:05:50.480] 怎么会对于这么大的事情错过\n",
            "[01:05:50.840 --> 01:05:51.320] 不可能\n",
            "[01:05:51.640 --> 01:05:52.760] 一定已经在做了\n",
            "[01:05:53.680 --> 01:05:55.360] 我这一堆人突然就跳出\n",
            "[01:05:55.360 --> 01:05:56.880] 看来今天有不少非输的人\n",
            "[01:05:56.880 --> 01:05:58.360] 别骂了再弄了\n",
            "[01:05:58.840 --> 01:06:00.240] 这个太有意思了\n",
            "[01:06:00.520 --> 01:06:02.040] 我特喜欢跟你们聊天\n",
            "[01:06:02.320 --> 01:06:03.360] 我觉得太开心了\n",
            "[01:06:05.240 --> 01:06:07.520] 刚才俊宇聊到了MEM\n",
            "[01:06:08.320 --> 01:06:09.120] 聊到了MEM\n",
            "[01:06:09.120 --> 01:06:11.760] 这个也是我今天觉得值得聊一聊的\n",
            "[01:06:12.080 --> 01:06:14.120] 这个其实是一个知识管理的东西\n",
            "[01:06:14.680 --> 01:06:18.480] 俊宇应该是一个超级有知识管理的习惯的人\n",
            "[01:06:19.040 --> 01:06:20.960] 你怎么看MEM这个应用\n",
            "[01:06:21.080 --> 01:06:22.040] 我相信你肯定用了\n",
            "[01:06:22.440 --> 01:06:24.240] 甚至我觉得你是不是也在思考\n",
            "[01:06:25.080 --> 01:06:25.840] 在国内的\n",
            "[01:06:25.840 --> 01:06:26.960] 包括你也做阅读\n",
            "[01:06:27.600 --> 01:06:30.000] 这个里边是不是有一些新的发挥的空间\n",
            "[01:06:30.440 --> 01:06:32.720] 俊宇这块是不是分享点想法\n",
            "[01:06:33.720 --> 01:06:35.680] 我其实不做知识管理\n",
            "[01:06:35.680 --> 01:06:36.560] 因为我不管理\n",
            "[01:06:37.040 --> 01:06:39.080] 我的梦想就是我就记下来\n",
            "[01:06:39.080 --> 01:06:40.280] 然后他替我管理\n",
            "[01:06:41.000 --> 01:06:42.680] 你只记录不管理\n",
            "[01:06:42.680 --> 01:06:43.040] 对吧\n",
            "[01:06:43.040 --> 01:06:44.200] 你希望他替你管理\n",
            "[01:06:44.200 --> 01:06:45.480] 对我真不想去\n",
            "[01:06:45.480 --> 01:06:47.880] 对我真的就没有办法去做什么\n",
            "[01:06:48.440 --> 01:06:52.680] 像那些效率爱好者一样去做双向网络\n",
            "[01:06:52.920 --> 01:06:54.440] 去做打很多标签\n",
            "[01:06:54.440 --> 01:06:55.040] 我真的做不了\n",
            "[01:06:55.040 --> 01:06:56.240] 因为我记录的东西实在太多了\n",
            "[01:06:57.040 --> 01:06:59.000] 所以我还是希望有工作来替我做管理\n",
            "[01:06:59.440 --> 01:07:01.080] MEM我还是挺失望的\n",
            "[01:07:01.080 --> 01:07:01.560] 说实话\n",
            "[01:07:01.560 --> 01:07:03.600] 我觉得他今天就是他吹嘘的东西\n",
            "[01:07:03.600 --> 01:07:04.720] 跟他实际做的还是差别太大了\n",
            "[01:07:05.080 --> 01:07:07.320] 其实他今天做的99%的功能\n",
            "[01:07:07.320 --> 01:07:09.320] 我觉得跟AI一点关系都没有\n",
            "[01:07:09.720 --> 01:07:11.000] 剩下1%的功能\n",
            "[01:07:11.080 --> 01:07:12.360] 可能里面的0.9%\n",
            "[01:07:12.480 --> 01:07:13.840] 跟notion其实是一样的\n",
            "[01:07:13.840 --> 01:07:15.320] 他只跟你单条笔记有关\n",
            "[01:07:15.680 --> 01:07:19.400] 他并不锁定我的整个的\n",
            "[01:07:20.400 --> 01:07:22.760] 大家都是全的GBT的外包商\n",
            "[01:07:23.600 --> 01:07:26.160] 对他制作其实都挺浅的\n",
            "[01:07:26.680 --> 01:07:29.240] 当然现在比的拼手术\n",
            "[01:07:29.240 --> 01:07:30.680] 谁接了 API\n",
            "[01:07:30.680 --> 01:07:32.400] 谁就觉得自己叫AI了\n",
            "[01:07:32.400 --> 01:07:35.240] 对\n",
            "[01:07:35.240 --> 01:07:36.920] 只是说他们连个index\n",
            "[01:07:37.240 --> 01:07:38.760] 可能都不接\n",
            "[01:07:38.920 --> 01:07:41.520] 我觉得还是过于仓促了点\n",
            "[01:07:42.200 --> 01:07:44.600] 你期待他应该做到什么程度\n",
            "[01:07:44.600 --> 01:07:48.400] 我们若不说不去说后面的原理的话\n",
            "[01:07:48.760 --> 01:07:51.360] 比如说我问他一个我的知识库里面的问题\n",
            "[01:07:51.360 --> 01:07:52.240] 他应该能答上来\n",
            "[01:07:53.160 --> 01:07:54.080] 这个很简单的\n",
            "[01:07:54.080 --> 01:07:56.560] 我用自然语言问一个我的知识库里面\n",
            "[01:07:56.560 --> 01:07:57.480] 我曾经回答过问题\n",
            "[01:07:57.480 --> 01:07:58.760] 他能够答上来\n",
            "[01:07:59.040 --> 01:08:00.520] 他能够举一把扇\n",
            "[01:08:00.640 --> 01:08:03.240] 他能够在就像刚刚傅深讲的\n",
            "[01:08:03.240 --> 01:08:06.840] 他能够在很不看起来很不关联的事情之间\n",
            "[01:08:06.840 --> 01:08:07.640] 找到联系\n",
            "[01:08:07.800 --> 01:08:08.800] 我们先不说后面\n",
            "[01:08:08.800 --> 01:08:10.320] 我们是去fight him\n",
            "[01:08:10.320 --> 01:08:12.600] 他还是去做相当搜索\n",
            "[01:08:12.600 --> 01:08:14.080] 还是我们不管这些技术原理\n",
            "[01:08:14.280 --> 01:08:16.640] 你去期待的是一个这样的一个东西\n",
            "[01:08:17.240 --> 01:08:18.320] 甚至进一步的\n",
            "[01:08:18.320 --> 01:08:21.360] 但我觉得这个还是产品经理或者说Ui UX设计师\n",
            "[01:08:21.360 --> 01:08:22.960] 可以去想很多的\n",
            "[01:08:22.960 --> 01:08:25.120] 那就是他到底怎么理解我掌握了什么\n",
            "[01:08:25.120 --> 01:08:26.280] 我没有掌握什么\n",
            "[01:08:26.800 --> 01:08:30.160] 甚至是不是需要我显心的来把某种东西记下来\n",
            "[01:08:30.400 --> 01:08:30.560] 对\n",
            "[01:08:30.560 --> 01:08:32.240] 因为更聪明的他能够察言观色\n",
            "[01:08:32.240 --> 01:08:34.440] 其实是这些东西能够去做得更好的\n",
            "[01:08:34.960 --> 01:08:37.200] 我最近在training我的一个\n",
            "[01:08:37.200 --> 01:08:38.560] GPT里面的一个session\n",
            "[01:08:38.560 --> 01:08:40.480] 就是试图让他知道我掌握了什么\n",
            "[01:08:40.840 --> 01:08:42.200] 然后给他一篇新的文章\n",
            "[01:08:42.200 --> 01:08:44.080] 他能只提取对我有用的要点\n",
            "[01:08:44.400 --> 01:08:46.760] 那现在我需要很显示的来告诉他\n",
            "[01:08:47.080 --> 01:08:48.800] 如果一个笔记的产品做得更好\n",
            "[01:08:48.800 --> 01:08:51.080] 一个浏览器可能做得更好\n",
            "[01:08:51.080 --> 01:08:52.360] 我觉得他是能够察言观色\n",
            "[01:08:52.360 --> 01:08:53.960] 能够注意到这些\n",
            "[01:08:55.200 --> 01:08:57.920] 但是现在如果大家所谓的AI\n",
            "[01:08:57.920 --> 01:09:00.680] 其实都是接了GPT的Open API\n",
            "[01:09:01.040 --> 01:09:01.400] 对吧\n",
            "[01:09:01.400 --> 01:09:03.120] 然后他现在局面到GPT4\n",
            "[01:09:03.120 --> 01:09:06.600] 他也只能一次单次就是输入最多2万个字\n",
            "[01:09:07.160 --> 01:09:09.520] 他没办法就是读取你所有的内容\n",
            "[01:09:09.520 --> 01:09:11.200] 然后一次性的给你做回复\n",
            "[01:09:11.920 --> 01:09:12.120] 对\n",
            "[01:09:12.120 --> 01:09:14.240] 所以这是我说先不管他的原理\n",
            "[01:09:14.840 --> 01:09:17.280] 但是你看其实今天不管是说像\n",
            "[01:09:17.280 --> 01:09:19.440] 我们知道的产品叫chat PDF\n",
            "[01:09:20.560 --> 01:09:20.720] 对\n",
            "[01:09:20.720 --> 01:09:23.760] 还有很多做全文总结的产品\n",
            "[01:09:23.760 --> 01:09:25.640] 他能够总结超过更长的文章\n",
            "[01:09:25.640 --> 01:09:27.400] 但你也知道他有一些小技巧\n",
            "[01:09:27.920 --> 01:09:30.400] 200页能读200页的字\n",
            "[01:09:30.680 --> 01:09:33.280] 人家是在里面加了一层预处理的\n",
            "[01:09:33.760 --> 01:09:34.840] 这加了预处理\n",
            "[01:09:36.000 --> 01:09:38.840] 有些小的trick怎么先去预先做一些搜索\n",
            "[01:09:39.280 --> 01:09:40.200] 做一些提取\n",
            "[01:09:40.560 --> 01:09:42.040] 其实那些事情暂时来讲\n",
            "[01:09:42.040 --> 01:09:45.760] 跟AGI跟AGI其实关系不是特别大\n",
            "[01:09:46.240 --> 01:09:48.760] 我个人的初浅的理解是这样\n",
            "[01:09:49.720 --> 01:09:53.160] 所以可能本质上前面还是接了一个个人的搜索引擎\n",
            "[01:09:53.160 --> 01:09:55.760] 然后只是说他怎么样更好的来present出来\n",
            "[01:09:57.240 --> 01:09:57.480] 对\n",
            "[01:09:58.080 --> 01:10:01.400] chat PDF对这个是embedding的\n",
            "[01:10:01.400 --> 01:10:03.560] 这个词儿蛮专业的\n",
            "[01:10:04.000 --> 01:10:05.040] 彭哥也不会解释\n",
            "[01:10:05.040 --> 01:10:06.720] 你们自己懂的就懂了\n",
            "[01:10:06.720 --> 01:10:07.840] 不懂的查一下\n",
            "[01:10:07.840 --> 01:10:09.360] 问一下chat dbt\n",
            "[01:10:09.360 --> 01:10:10.280] 这句话啥意思\n",
            "[01:10:10.280 --> 01:10:12.480] 对这个词我这个词还真是我\n",
            "[01:10:12.840 --> 01:10:13.920] 前几周问了很多遍\n",
            "[01:10:13.920 --> 01:10:15.280] 并到底这个是什么意思\n",
            "[01:10:15.800 --> 01:10:16.840] 他也没给我解释明白\n",
            "[01:10:18.720 --> 01:10:19.040] 哎呀\n",
            "[01:10:19.040 --> 01:10:20.200] 我觉得聊到这儿\n",
            "[01:10:20.640 --> 01:10:23.360] 这个正好引发了一个问题\n",
            "[01:10:23.360 --> 01:10:25.840] 就是你刚才军域说的那个感觉\n",
            "[01:10:25.960 --> 01:10:28.440] 包括这个刚才复盛说的\n",
            "[01:10:28.440 --> 01:10:31.280] 说接个API就觉得自己是AI了\n",
            "[01:10:31.280 --> 01:10:33.400] 今天如果我们做产品的兴奋\n",
            "[01:10:33.400 --> 01:10:37.840] 就是我赶紧拿个什么东西上做个接个API做个feature\n",
            "[01:10:37.840 --> 01:10:38.080] 对吧\n",
            "[01:10:38.080 --> 01:10:39.560] 我就觉得自己很厉害了\n",
            "[01:10:40.040 --> 01:10:42.480] 可能这个是比较丢产品经理的人\n",
            "[01:10:43.080 --> 01:10:45.320] 就产品经理不是这么想问题的\n",
            "[01:10:45.320 --> 01:10:47.120] 所以这也引发了我们\n",
            "[01:10:47.120 --> 01:10:48.760] 我们刚才聊了好几个产品\n",
            "[01:10:48.760 --> 01:10:51.920] 这个我们其实也应该要聊聊这个产品经理\n",
            "[01:10:51.920 --> 01:10:53.080] 在下一个时代什么样\n",
            "[01:10:53.840 --> 01:10:54.240] 好\n",
            "[01:10:54.240 --> 01:10:58.200] 那我们最后这个环节还是要聊聊产品经理吧\n",
            "[01:10:58.200 --> 01:11:00.200] 其实就我觉得很重要啊\n",
            "[01:11:00.200 --> 01:11:04.800] 这个时代的产品经理到底需要哪些native的东西\n",
            "[01:11:04.800 --> 01:11:06.080] 需要一些什么样的气质\n",
            "[01:11:06.080 --> 01:11:07.440] 或者换个说法\n",
            "[01:11:07.440 --> 01:11:10.680] 之前说到这个古典型产品经理\n",
            "[01:11:10.680 --> 01:11:12.360] 就是就敢于想象\n",
            "[01:11:12.360 --> 01:11:13.560] 敢于定义需求\n",
            "[01:11:13.560 --> 01:11:15.160] 和后来的叫数据型产品经理\n",
            "[01:11:15.160 --> 01:11:17.240] 就看数AB测试\n",
            "[01:11:17.240 --> 01:11:19.760] 好像有一段时间就变成后者是主体\n",
            "[01:11:19.760 --> 01:11:21.120] 前者有没太大用了\n",
            "[01:11:21.120 --> 01:11:23.960] 因为这个产业就不留给他们创新的机会了\n",
            "[01:11:24.000 --> 01:11:27.960] 傅盛觉得是不是现在这种古典型产品经理对吧\n",
            "[01:11:27.960 --> 01:11:30.480] 去能定义需求的产品经理的时代又回来了\n",
            "[01:11:30.480 --> 01:11:31.760] 随着这一波技术变革\n",
            "[01:11:33.400 --> 01:11:36.600] 我觉得至少现阶段是非常有机会的\n",
            "[01:11:36.600 --> 01:11:39.680] 但是这个行业怎么发展还得看\n",
            "[01:11:39.680 --> 01:11:42.320] 但这个阶段的确结合\n",
            "[01:11:42.320 --> 01:11:44.080] 因为就一个新的东西出现了\n",
            "[01:11:44.080 --> 01:11:45.560] 大多数人不熟悉吧\n",
            "[01:11:45.560 --> 01:11:47.520] 产品经理就是把这个大家不熟悉的东西\n",
            "[01:11:47.520 --> 01:11:49.400] 变成大部分人可以使用吧\n",
            "[01:11:49.400 --> 01:11:51.480] 其实刚你们讲移动互联时代\n",
            "[01:11:51.600 --> 01:11:54.280] 我觉得有点像我当年做360的时代\n",
            "[01:11:54.880 --> 01:11:56.440] 安全工具早都有了\n",
            "[01:11:56.440 --> 01:11:58.240] 但都得专业人会用对吧\n",
            "[01:11:58.240 --> 01:11:59.200] 我就做一个东西\n",
            "[01:11:59.200 --> 01:12:01.360] 就把这些东西链接起来了\n",
            "[01:12:01.360 --> 01:12:02.520] 然后一下子\n",
            "[01:12:02.520 --> 01:12:03.920] 但历史不一定是重复\n",
            "[01:12:04.120 --> 01:12:05.600] 就会不会有这样的机会\n",
            "[01:12:05.600 --> 01:12:07.080] 说实话我也不太清楚\n",
            "[01:12:07.840 --> 01:12:10.280] 我倒觉得电动API没什么毛病\n",
            "[01:12:10.400 --> 01:12:13.760] 其实是大家出于自己的能力\n",
            "[01:12:13.920 --> 01:12:15.880] 然后其实是很多人要参与\n",
            "[01:12:15.920 --> 01:12:17.720] 但你其实所谓春江水软\n",
            "[01:12:17.720 --> 01:12:19.920] 你得先在水里面游才行\n",
            "[01:12:20.320 --> 01:12:21.080] 我举一个例子\n",
            "[01:12:21.240 --> 01:12:23.680] 就比如说极客这个团队\n",
            "[01:12:23.920 --> 01:12:27.200] 他们做了图像那块做了慢镜\n",
            "[01:12:27.200 --> 01:12:29.360] 就是给你一堆的照片\n",
            "[01:12:29.360 --> 01:12:31.360] 然后当然他可能也是调用别人的大模型\n",
            "[01:12:31.640 --> 01:12:33.000] 调用别人的接口\n",
            "[01:12:33.000 --> 01:12:36.120] 然后给你生成更好看的就是头像照片\n",
            "[01:12:36.120 --> 01:12:39.240] 然后他们自己的同事应该做了一个\n",
            "[01:12:39.240 --> 01:12:42.880] 在ChinaGTB发布的应该头两天里面\n",
            "[01:12:42.880 --> 01:12:45.840] 就做了一个Chrome的插件\n",
            "[01:12:45.840 --> 01:12:48.240] 就类似今天Nubian的做法\n",
            "[01:12:48.240 --> 01:12:52.080] 最初他们在谷歌的结果页里面已经做出来了\n",
            "[01:12:52.280 --> 01:12:53.600] 通过那种插件的形式\n",
            "[01:12:53.600 --> 01:12:57.840] 然后后来极客又把他们员工的插件\n",
            "[01:12:57.840 --> 01:12:59.000] 又收购回来了\n",
            "[01:12:59.000 --> 01:12:59.680] 自己来做\n",
            "[01:12:59.680 --> 01:13:01.520] 然后做了非常多那种的拓展\n",
            "[01:13:01.520 --> 01:13:05.120] 我觉得他们感觉就特别像2011年的时候\n",
            "[01:13:05.120 --> 01:13:06.600] 张一鸣他们那边去搞什么\n",
            "[01:13:06.600 --> 01:13:09.480] 就是搞小景图那一堆乱七八糟的事情\n",
            "[01:13:09.480 --> 01:13:10.680] 就是看到一个大方向\n",
            "[01:13:10.680 --> 01:13:13.040] 不断去试 不断去测需求\n",
            "[01:13:13.040 --> 01:13:16.000] 因为像他们做TrinityBT\n",
            "[01:13:16.840 --> 01:13:18.960] 就是谷歌的插件\n",
            "[01:13:18.960 --> 01:13:20.120] 就很快\n",
            "[01:13:20.120 --> 01:13:21.600] 我印象里面很快\n",
            "[01:13:21.720 --> 01:13:23.640] 很快就达到了多少的\n",
            "[01:13:23.640 --> 01:13:25.560] 什么规模的用户量级我不知道\n",
            "[01:13:25.560 --> 01:13:27.560] 但我的感觉就是\n",
            "[01:13:27.560 --> 01:13:31.080] 当然有一些人是要去像百度\n",
            "[01:13:31.080 --> 01:13:34.080] 或者说像其他的一些团队是需要\n",
            "[01:13:34.080 --> 01:13:36.040] 就譬如说去硬供的\n",
            "[01:13:36.040 --> 01:13:38.040] 但我觉得也有一些团队需要在里面\n",
            "[01:13:38.040 --> 01:13:39.800] 需要很快的获得正反馈\n",
            "[01:13:39.800 --> 01:13:41.960] 因为我觉得持续获得正反馈\n",
            "[01:13:41.960 --> 01:13:43.480] 它比较重要一点\n",
            "[01:13:43.480 --> 01:13:44.080] 对\n",
            "[01:13:44.680 --> 01:13:45.520] 好的\n",
            "[01:13:46.000 --> 01:13:48.520] 我刚讲到就是说\n",
            "[01:13:48.520 --> 01:13:50.520] 其实这就是一个\n",
            "[01:13:50.520 --> 01:13:53.480] 怎么去预先找到需求的时代\n",
            "[01:13:53.480 --> 01:13:56.200] 然后有点像当年我说360一样\n",
            "[01:13:56.200 --> 01:13:58.080] 有了一堆的这种专业工具了\n",
            "[01:13:58.080 --> 01:14:00.360] 然后你把它找到你的用户群\n",
            "[01:14:00.360 --> 01:14:00.600] 对吧\n",
            "[01:14:00.600 --> 01:14:02.560] 今天TrinityBT虽然说这么火\n",
            "[01:14:02.560 --> 01:14:03.920] 但是我估计\n",
            "[01:14:03.920 --> 01:14:07.680] 估计有80%的人应该还是没有听过的\n",
            "[01:14:07.680 --> 01:14:08.000] 对吧\n",
            "[01:14:08.000 --> 01:14:11.720] 真正用过的可能也就5%\n",
            "[01:14:11.720 --> 01:14:13.720] 在美国可能多一些\n",
            "[01:14:13.720 --> 01:14:14.040] 对吧\n",
            "[01:14:14.040 --> 01:14:15.000] 所以这个时候\n",
            "[01:14:15.040 --> 01:14:15.680] 这第一个\n",
            "[01:14:15.680 --> 01:14:17.840] 第二个所谓的魔法师这件事\n",
            "[01:14:17.840 --> 01:14:18.160] 对吧\n",
            "[01:14:18.160 --> 01:14:20.360] 其实里面还是有挺多门道的\n",
            "[01:14:20.360 --> 01:14:22.960] 所以我也是很久没有对一个产品\n",
            "[01:14:22.960 --> 01:14:24.080] 这样的自己\n",
            "[01:14:24.080 --> 01:14:25.560] 你想我多少年都不用Mac电脑了\n",
            "[01:14:25.560 --> 01:14:27.880] 我现在出来都背一个Mac电脑\n",
            "[01:14:27.880 --> 01:14:31.520] 因为主要就是想给自己树立一个\n",
            "[01:14:31.520 --> 01:14:33.480] 编个小程序的目标嘛\n",
            "[01:14:33.480 --> 01:14:35.120] 然后在不找任何程序员\n",
            "[01:14:35.120 --> 01:14:37.800] 不找任何设计师的情况下写出来\n",
            "[01:14:37.800 --> 01:14:38.120] 对吧\n",
            "[01:14:38.120 --> 01:14:40.720] 这个想反向给我们的程序员压力\n",
            "[01:14:40.720 --> 01:14:42.440] 我说你们这个\n",
            "[01:14:42.440 --> 01:14:43.360] 这个基本的\n",
            "[01:14:43.360 --> 01:14:44.800] 就以前你们觉得经验\n",
            "[01:14:44.800 --> 01:14:46.760] 可能就是在一个模块底下\n",
            "[01:14:46.760 --> 01:14:47.920] 能够去调一个东西\n",
            "[01:14:47.920 --> 01:14:49.360] 一个环境别人不知道的\n",
            "[01:14:49.360 --> 01:14:49.680] 对吧\n",
            "[01:14:49.680 --> 01:14:51.400] 还有什么服务端的\n",
            "[01:14:51.400 --> 01:14:52.800] 看不起什么客户端的\n",
            "[01:14:52.800 --> 01:14:54.120] 我说以后这些都会打通的\n",
            "[01:14:54.120 --> 01:14:56.440] 因为这些knowhow都是割裂的\n",
            "[01:14:56.440 --> 01:14:58.680] 所以你认为这是所谓的经验\n",
            "[01:14:58.680 --> 01:15:00.840] 这经验壁垒就被打掉了\n",
            "[01:15:00.840 --> 01:15:01.000] 好\n",
            "[01:15:01.000 --> 01:15:02.560] 那么作为产品经理来说\n",
            "[01:15:02.560 --> 01:15:05.360] 就是自己还是得先学习这个东西\n",
            "[01:15:05.360 --> 01:15:07.600] 就是得花挺多时间去了解这个东西\n",
            "[01:15:07.600 --> 01:15:08.960] 就是我说我用它的核心\n",
            "[01:15:08.960 --> 01:15:10.800] 是我得知道它能力边界在哪\n",
            "[01:15:10.800 --> 01:15:11.800] 因为一个产品经理\n",
            "[01:15:11.800 --> 01:15:13.360] 如果只是听到别人去讲\n",
            "[01:15:13.360 --> 01:15:14.760] 这东西怎么样或者怎么样\n",
            "[01:15:14.760 --> 01:15:17.000] 你很难设计出一款好的产品\n",
            "[01:15:17.000 --> 01:15:17.400] 因为对吧\n",
            "[01:15:17.400 --> 01:15:19.760] 它既有很多一般人不知的能力\n",
            "[01:15:19.760 --> 01:15:21.640] 但是它又有它的能力边界\n",
            "[01:15:21.640 --> 01:15:23.120] 然后它又提供哪些东西\n",
            "[01:15:23.120 --> 01:15:24.520] 能够去真正结合好\n",
            "[01:15:24.520 --> 01:15:26.600] 它能力边界给设计出来\n",
            "[01:15:26.600 --> 01:15:27.720] 我觉得所以这是一个\n",
            "[01:15:27.720 --> 01:15:29.800] 真的你可以发挥主动性啊\n",
            "[01:15:29.800 --> 01:15:30.960] 去完成的\n",
            "[01:15:30.960 --> 01:15:31.200] 对啊\n",
            "[01:15:31.200 --> 01:15:32.960] 我说以后我们跟TPT的区别\n",
            "[01:15:32.960 --> 01:15:34.160] 就是任务性的工作\n",
            "[01:15:34.160 --> 01:15:35.080] 基本它都能干\n",
            "[01:15:35.080 --> 01:15:36.520] 就从小慢慢干到大\n",
            "[01:15:36.520 --> 01:15:38.840] 以后就主动性的工作是我们的特点\n",
            "[01:15:38.840 --> 01:15:39.680] 这也是产品经理\n",
            "[01:15:39.680 --> 01:15:42.360] 真正的意义和特质之所在嘛\n",
            "[01:15:42.360 --> 01:15:42.880] 然后呢\n",
            "[01:15:42.880 --> 01:15:43.800] 再讲的那个点\n",
            "[01:15:43.800 --> 01:15:46.920] 就今天所有的应用都值得被重做一遍\n",
            "[01:15:46.920 --> 01:15:48.720] 真的那个我前几个月\n",
            "[01:15:48.720 --> 01:15:51.120] 搜AI打头的APP\n",
            "[01:15:51.120 --> 01:15:54.240] 我在美国商店搜的大概不多\n",
            "[01:15:54.240 --> 01:15:55.360] 前两天我搜了一次\n",
            "[01:15:55.360 --> 01:15:56.120] 我已经看呆了\n",
            "[01:15:56.120 --> 01:15:57.600] 我已经下了20个还没拉完\n",
            "[01:15:57.600 --> 01:16:00.240] 最后已经看到我这个什么AI boyfriend\n",
            "[01:16:00.240 --> 01:16:01.920] AI girlfriend AI cowboy\n",
            "[01:16:01.920 --> 01:16:04.600] 然后什么做坏的都很多\n",
            "[01:16:04.600 --> 01:16:05.280] 哎呀\n",
            "[01:16:05.280 --> 01:16:06.640] 已经是雨后春筍了\n",
            "[01:16:06.640 --> 01:16:10.080] 所以大家这个还是得全力以赴吧\n",
            "[01:16:10.080 --> 01:16:12.160] 我觉得这是一个非常好的机会\n",
            "[01:16:12.200 --> 01:16:13.480] 也是一次大的变革\n",
            "[01:16:13.480 --> 01:16:15.800] 所以产品经理应该是站在最好的位置上\n",
            "[01:16:15.800 --> 01:16:16.960] 这是我自己的认为啊\n",
            "[01:16:17.720 --> 01:16:18.440] 嗯\n",
            "[01:16:18.440 --> 01:16:21.600] 这傅胜可是这个中国的\n",
            "[01:16:21.600 --> 01:16:24.400] 在互联网时代的早期的\n",
            "[01:16:24.400 --> 01:16:25.960] 非常优秀的产品经理啊\n",
            "[01:16:25.960 --> 01:16:27.400] 这是当年产品经理\n",
            "[01:16:27.400 --> 01:16:28.640] 这是有段位的\n",
            "[01:16:28.640 --> 01:16:30.560] 名人堂里面也算一号的啊\n",
            "[01:16:30.560 --> 01:16:32.680] 今天又再说产品经理们\n",
            "[01:16:32.680 --> 01:16:34.400] 就是要重新站出来了\n",
            "[01:16:34.400 --> 01:16:34.800] 对吧\n",
            "[01:16:34.800 --> 01:16:36.480] 所有的产品都值得做一遍\n",
            "[01:16:36.480 --> 01:16:40.200] 我觉得这总体听起来还是挺值得拥抱的一个时代啊\n",
            "[01:16:40.200 --> 01:16:41.160] 军运怎么看\n",
            "[01:16:41.160 --> 01:16:42.560] 在这个时代里边\n",
            "[01:16:42.560 --> 01:16:44.880] 产品经理需要一些什么样的素质\n",
            "[01:16:44.880 --> 01:16:47.440] 或者说过去产品经理的一些什么样的\n",
            "[01:16:47.440 --> 01:16:51.200] 可能随着时代发展被沉寂的素质需要回归吗\n",
            "[01:16:51.200 --> 01:16:54.320] 你会怎么定义在今天能把产品做好的人\n",
            "[01:16:54.320 --> 01:16:55.200] 他需要什么\n",
            "[01:16:56.480 --> 01:16:57.760] 我先岔开一点点\n",
            "[01:16:57.760 --> 01:16:58.760] 因为刚刚讲到是说\n",
            "[01:16:58.760 --> 01:17:03.000] 这样的产品就是简单的接了OpenAI的API\n",
            "[01:17:03.000 --> 01:17:04.320] 我也觉得这个问题呢\n",
            "[01:17:04.320 --> 01:17:05.080] 不是特别的大\n",
            "[01:17:05.080 --> 01:17:06.360] 但是呢\n",
            "[01:17:06.360 --> 01:17:07.680] 可能有两种场景\n",
            "[01:17:07.680 --> 01:17:08.240] 一种产品呢\n",
            "[01:17:08.240 --> 01:17:10.720] 是说有一个已有的产品\n",
            "[01:17:10.720 --> 01:17:13.040] 他加上这么的一层\n",
            "[01:17:13.040 --> 01:17:17.080] 那这个我觉得当然是说他对于一个已有产品的一个一个增强\n",
            "[01:17:17.080 --> 01:17:17.920] 另外一层呢\n",
            "[01:17:17.920 --> 01:17:20.440] 我可能不太同意潘乱老师的一个看法呢\n",
            "[01:17:20.440 --> 01:17:22.920] 我觉得可能不太像11年\n",
            "[01:17:22.920 --> 01:17:26.800] 一鸣做了头条内行段子等等一系列产品\n",
            "[01:17:26.800 --> 01:17:30.200] 我觉得可能今天很多在接了GPA的产品\n",
            "[01:17:30.200 --> 01:17:31.360] 更像是07年\n",
            "[01:17:31.360 --> 01:17:34.960] 我们在iPhone上面做了个指南针\n",
            "[01:17:34.960 --> 01:17:37.360] 因为他对于一个说说白了\n",
            "[01:17:37.360 --> 01:17:39.800] 我们做手机APP不也就是调用了\n",
            "[01:17:39.800 --> 01:17:41.200] iOS的若干API吗\n",
            "[01:17:42.320 --> 01:17:44.920] 只是说这个调用API的之后的排列的组合\n",
            "[01:17:44.920 --> 01:17:46.480] 它的创造性有多大\n",
            "[01:17:46.480 --> 01:17:47.720] 这是另外一个问题\n",
            "[01:17:47.720 --> 01:17:50.200] 但我们说这个Promo魔法师\n",
            "[01:17:50.200 --> 01:17:51.520] 也还是挺神秘的一个事情\n",
            "[01:17:51.520 --> 01:17:52.400] 也还是挺有意思的\n",
            "[01:17:52.400 --> 01:17:54.080] 但毕竟来讲的话\n",
            "[01:17:54.080 --> 01:17:56.200] 我觉得它的厚度就按取凯的说法\n",
            "[01:17:56.200 --> 01:17:57.040] 就还是相对来讲\n",
            "[01:17:57.040 --> 01:17:59.400] 还是还是比较薄的\n",
            "[01:17:59.400 --> 01:18:01.680] 但我可能就是会不断提醒自己的\n",
            "[01:18:01.680 --> 01:18:06.520] 就是说不要就是像早年做了一个简单的指南针工具\n",
            "[01:18:06.520 --> 01:18:07.400] 你很开心\n",
            "[01:18:07.400 --> 01:18:08.800] 做了个优化产品很开心\n",
            "[01:18:08.800 --> 01:18:11.400] 今天正好翻了一下2011年的时候\n",
            "[01:18:11.400 --> 01:18:12.920] 豌豆夹的排行榜\n",
            "[01:18:12.920 --> 01:18:16.880] 那上面的产品真的今天可能都已经完全不会想起来了\n",
            "[01:18:16.880 --> 01:18:19.240] 安卓魔法师等等吧\n",
            "[01:18:19.240 --> 01:18:21.720] 那包括我们当时做手机管理\n",
            "[01:18:21.720 --> 01:18:23.280] 那其实也是会很容易说\n",
            "[01:18:23.280 --> 01:18:26.520] 因为他当时早期Early Adopter里面\n",
            "[01:18:26.520 --> 01:18:28.000] DEC人群里面用的很好\n",
            "[01:18:28.000 --> 01:18:29.160] 所以你可能忘了是说\n",
            "[01:18:29.160 --> 01:18:30.760] 当他走向更大众的人群的时候\n",
            "[01:18:30.760 --> 01:18:33.840] 其实会有一些不太一样的一些需求\n",
            "[01:18:33.840 --> 01:18:36.440] 所以这是我另外唱个反调\n",
            "[01:18:36.440 --> 01:18:37.680] 然后古典产品经理呢\n",
            "[01:18:37.680 --> 01:18:39.560] 其实我不是一般智取设计师吗\n",
            "[01:18:39.560 --> 01:18:41.680] 我也不支撑产品经理\n",
            "[01:18:41.680 --> 01:18:43.880] 然后我觉得比较传统的设计师\n",
            "[01:18:43.880 --> 01:18:45.360] 我理解他的核心能力呢\n",
            "[01:18:45.360 --> 01:18:50.080] 还是把用户的需求和解决方案对接\n",
            "[01:18:50.080 --> 01:18:51.920] 他其实也不是创造需求\n",
            "[01:18:51.920 --> 01:18:53.800] 基本上需求不是创造出来的\n",
            "[01:18:53.800 --> 01:18:55.360] 需求是挖掘出来的\n",
            "[01:18:55.360 --> 01:18:57.840] 一个人他必定已经有某种需求\n",
            "[01:18:57.840 --> 01:18:59.520] 只是原来被摁住了\n",
            "[01:18:59.520 --> 01:19:00.400] 原来被摁住了\n",
            "[01:19:00.400 --> 01:19:02.160] 原来没有被释放\n",
            "[01:19:02.160 --> 01:19:05.400] 那其实产品经理的或者产品设计师的能力\n",
            "[01:19:05.400 --> 01:19:07.440] 还是跟人打交道的能力\n",
            "[01:19:07.440 --> 01:19:11.400] 还是对于人有洞察这样的一个能力\n",
            "[01:19:11.400 --> 01:19:15.960] 我觉得这是比较古典的一种能力\n",
            "[01:19:15.960 --> 01:19:19.800] 那今天好像你放到AI这个新的话部上面\n",
            "[01:19:19.800 --> 01:19:21.160] 这个新的领域上面\n",
            "[01:19:21.160 --> 01:19:23.840] 他跟人打交道的这一部分似乎并没有变化\n",
            "[01:19:23.840 --> 01:19:25.760] 对那像我最近在想的问题还是说\n",
            "[01:19:25.760 --> 01:19:30.520] 那我们一个人每天24小时里面有多少事情\n",
            "[01:19:30.520 --> 01:19:34.800] 是有可能这种甚至是AI AGI能帮我们解决的\n",
            "[01:19:34.840 --> 01:19:37.440] 但另外一端我觉得是会更难一点的\n",
            "[01:19:37.440 --> 01:19:39.680] 就是当年拿到一个iPhone\n",
            "[01:19:39.680 --> 01:19:41.880] 他能干什么这个并不难理解\n",
            "[01:19:41.880 --> 01:19:42.280] 对吧\n",
            "[01:19:42.280 --> 01:19:45.000] 其实你不需要你不需要读懂技术文档\n",
            "[01:19:45.000 --> 01:19:48.000] 你能知道说一个iPhone能干啥\n",
            "[01:19:48.000 --> 01:19:49.440] 他这样的一个触摸屏\n",
            "[01:19:49.440 --> 01:19:51.640] 320x240的触摸屏\n",
            "[01:19:51.640 --> 01:19:54.160] 他有陀螺仪大屏幕能干嘛\n",
            "[01:19:54.160 --> 01:19:55.680] 你也有一些想象\n",
            "[01:19:55.680 --> 01:19:57.200] 但是今天拿GPT来讲\n",
            "[01:19:57.200 --> 01:19:58.040] 他能干嘛\n",
            "[01:19:58.040 --> 01:19:59.720] 别说产品经理们吧\n",
            "[01:19:59.720 --> 01:20:02.440] 工程师们可能学术界其实都还在想\n",
            "[01:20:02.440 --> 01:20:03.800] 你今天看到的很多论文\n",
            "[01:20:03.800 --> 01:20:07.600] 其实就是在用Chart GPT在研究他到底能干嘛\n",
            "[01:20:07.600 --> 01:20:10.000] 我觉得这个对于产品经理来理解\n",
            "[01:20:10.000 --> 01:20:11.400] 就是后面他到底能干嘛\n",
            "[01:20:11.400 --> 01:20:12.000] 这个时候来讲\n",
            "[01:20:12.000 --> 01:20:14.280] 门槛要变得变得更高了\n",
            "[01:20:14.280 --> 01:20:15.920] 如果说我们的工作没有变化\n",
            "[01:20:15.920 --> 01:20:18.320] 他还是去对接去挖掘人的需求\n",
            "[01:20:18.320 --> 01:20:20.960] 把他用解决方案给实现出来\n",
            "[01:20:20.960 --> 01:20:22.760] 发现你要去理解这个解决方案的难度\n",
            "[01:20:22.760 --> 01:20:24.960] 我觉得是是变得更高了的\n",
            "[01:20:24.960 --> 01:20:27.720] 这个我觉得是可能像我追起来\n",
            "[01:20:27.720 --> 01:20:29.960] 我觉得也会也会蛮吃力的\n",
            "[01:20:29.960 --> 01:20:32.280] 他跟我们原来做原来新\n",
            "[01:20:32.320 --> 01:20:34.080] 因为毕竟我们说10年那个时代\n",
            "[01:20:34.080 --> 01:20:34.880] 1年那个时代\n",
            "[01:20:34.880 --> 01:20:36.040] 我们招产品经理\n",
            "[01:20:36.040 --> 01:20:37.000] 招产品设计师\n",
            "[01:20:37.000 --> 01:20:39.760] 只要他是对于所谓用户体验这事有sense\n",
            "[01:20:39.760 --> 01:20:41.600] 其实就是一个很大的优势了\n",
            "[01:20:41.600 --> 01:20:44.280] 因为当年大部分产品是不怎么讲究用户体验的\n",
            "[01:20:44.280 --> 01:20:45.480] 今天来讲的话\n",
            "[01:20:45.480 --> 01:20:47.320] 我觉得这个门槛就高得多了\n",
            "[01:20:47.320 --> 01:20:50.080] 跟俊宇再唱一下反调\n",
            "[01:20:50.080 --> 01:20:52.280] 然后我是觉得就是\n",
            "[01:20:52.280 --> 01:20:54.120] 今天的一切的东西\n",
            "[01:20:54.120 --> 01:20:55.680] 它其实都在被加速\n",
            "[01:20:55.680 --> 01:20:57.480] 在移动早期的时候\n",
            "[01:20:57.480 --> 01:21:00.680] 是存在了那么多年的非共识的机会\n",
            "[01:21:01.080 --> 01:21:02.360] 就比如说富盛做360\n",
            "[01:21:02.360 --> 01:21:03.280] 他最初做的时候\n",
            "[01:21:03.280 --> 01:21:04.240] 估计也没人\n",
            "[01:21:04.240 --> 01:21:08.280] 就是你让当时的小狮子那家公司\n",
            "[01:21:08.280 --> 01:21:09.080] 我忘了叫什么了\n",
            "[01:21:09.080 --> 01:21:10.560] 就是或者卡巴斯基\n",
            "[01:21:10.560 --> 01:21:12.080] 不觉得你干的是啥事\n",
            "[01:21:12.200 --> 01:21:14.320] 就是干就是可能他觉得富盛当时比较傻\n",
            "[01:21:14.320 --> 01:21:16.400] 为什么叫瑞星\n",
            "[01:21:16.400 --> 01:21:18.160] 但今天不可能\n",
            "[01:21:18.160 --> 01:21:19.800] 瑞星的名字都被忘了\n",
            "[01:21:19.800 --> 01:21:20.520] 哎呀真是\n",
            "[01:21:20.520 --> 01:21:22.080] 天呐\n",
            "[01:21:22.080 --> 01:21:23.680] 我就记得小狮子\n",
            "[01:21:23.680 --> 01:21:24.680] 但是今天不可能\n",
            "[01:21:24.800 --> 01:21:26.360] 你看百度这么快的响应\n",
            "[01:21:26.360 --> 01:21:28.200] 百度是在推荐这个\n",
            "[01:21:28.200 --> 01:21:29.480] 就是他移动探索\n",
            "[01:21:29.480 --> 01:21:30.480] 探索走了弯路\n",
            "[01:21:30.480 --> 01:21:32.200] 然后对于推荐这个事情\n",
            "[01:21:32.200 --> 01:21:34.400] 也相当于是理解的慢了一点\n",
            "[01:21:34.440 --> 01:21:37.000] 对早些年其实就是人才不断\n",
            "[01:21:37.000 --> 01:21:38.160] 从百度流向到字节\n",
            "[01:21:38.840 --> 01:21:41.600] 但我觉得今天就是大家对于大的趋势\n",
            "[01:21:41.600 --> 01:21:42.960] 机会判断能力\n",
            "[01:21:42.960 --> 01:21:44.400] 以及响应的意识\n",
            "[01:21:44.400 --> 01:21:45.720] 比前面强了无数倍\n",
            "[01:21:45.880 --> 01:21:47.880] 我觉得真的不能再用那种\n",
            "[01:21:47.880 --> 01:21:49.520] 就是认为这处在一个更早期\n",
            "[01:21:49.560 --> 01:21:51.960] 我觉得今天就是所有都在被加速\n",
            "[01:21:52.280 --> 01:21:53.600] 这个我也蛮同意的\n",
            "[01:21:54.160 --> 01:21:56.000] 看来对产品经理的考验\n",
            "[01:21:56.320 --> 01:21:58.800] 即使机会考验也越来越大\n",
            "[01:21:59.120 --> 01:22:01.320] 不过我也纠正你一下\n",
            "[01:22:01.320 --> 01:22:02.560] 当时那个小狮子\n",
            "[01:22:02.560 --> 01:22:05.280] 那个瑞星可不是啥都没做\n",
            "[01:22:05.680 --> 01:22:07.160] 他做的还是很凶的\n",
            "[01:22:07.160 --> 01:22:08.440] 也做了卡卡助手\n",
            "[01:22:08.440 --> 01:22:10.040] 就是战略防御在每个阶段\n",
            "[01:22:10.040 --> 01:22:10.920] 他都是有的\n",
            "[01:22:11.360 --> 01:22:13.240] 其实还是一个思维逻辑\n",
            "[01:22:13.240 --> 01:22:14.320] 就当瑞星跟我聊\n",
            "[01:22:14.320 --> 01:22:16.760] 就是因为他那个等我离开的时候\n",
            "[01:22:16.760 --> 01:22:17.960] 他就说其他们\n",
            "[01:22:18.240 --> 01:22:20.800] 首先就对这个东西有用户量子的事\n",
            "[01:22:20.800 --> 01:22:21.640] 他们不关心\n",
            "[01:22:21.640 --> 01:22:22.600] 就商业逻辑上\n",
            "[01:22:22.600 --> 01:22:24.640] 他不是很理解能怎么做\n",
            "[01:22:24.840 --> 01:22:25.840] 那就不讲细节了\n",
            "[01:22:25.840 --> 01:22:28.040] 我的意思就是说其实卷都在卷\n",
            "[01:22:28.040 --> 01:22:29.840] 只是现在卷的程度\n",
            "[01:22:29.840 --> 01:22:31.760] 大家就由于互联网更快\n",
            "[01:22:32.080 --> 01:22:34.240] 但是反过来你动手也会更快\n",
            "[01:22:34.800 --> 01:22:37.400] 我觉得之前如果今天的话\n",
            "[01:22:37.400 --> 01:22:39.480] 今天就真的已经是正规军做到了\n",
            "[01:22:39.480 --> 01:22:41.080] 对就不会像早年那种\n",
            "[01:22:41.080 --> 01:22:43.600] 留给大家那么多的就是真空时间\n",
            "[01:22:44.400 --> 01:22:48.120] 这个我觉得傅胜不是当年是傅胜说的\n",
            "[01:22:48.240 --> 01:22:50.760] 就是不要战术上勤奋\n",
            "[01:22:50.760 --> 01:22:52.040] 战略上懒惰\n",
            "[01:22:52.080 --> 01:22:52.520] 对吧\n",
            "[01:22:52.520 --> 01:22:54.520] 某种程度上就是产品经理们\n",
            "[01:22:54.560 --> 01:22:56.600] 也不要只是在事上勤奋\n",
            "[01:22:56.640 --> 01:22:58.040] 但这个底层的逻辑\n",
            "[01:22:58.040 --> 01:22:59.440] 什么是这个时代的\n",
            "[01:22:59.440 --> 01:23:01.160] native的东西的思考\n",
            "[01:23:01.160 --> 01:23:02.600] 这个事要更加勤奋\n",
            "[01:23:02.600 --> 01:23:04.200] 可能我觉得才是根本性\n",
            "[01:23:04.200 --> 01:23:06.440] 就像刚才那几个瑞星的例子\n",
            "[01:23:06.480 --> 01:23:08.160] 也在做你类似的动作\n",
            "[01:23:08.160 --> 01:23:10.320] 他没有找到根本的逻辑\n",
            "[01:23:10.360 --> 01:23:11.680] 其实也不太能赢的\n",
            "[01:23:11.720 --> 01:23:13.280] 所以我觉得可能在这个时代\n",
            "[01:23:13.280 --> 01:23:14.720] 也是一样要面对的东西\n",
            "[01:23:15.040 --> 01:23:17.640] 现在还是一个让人兴奋\n",
            "[01:23:17.640 --> 01:23:19.240] 但是又所有的东西\n",
            "[01:23:19.440 --> 01:23:21.520] 其实我觉得都有共识\n",
            "[01:23:21.640 --> 01:23:23.000] 所有东西值得再做一遍\n",
            "[01:23:23.200 --> 01:23:24.880] 都有机会这都是共识\n",
            "[01:23:24.920 --> 01:23:26.240] 但是怎么做更对\n",
            "[01:23:26.480 --> 01:23:27.520] 边界在哪\n",
            "[01:23:27.520 --> 01:23:28.120] 对吧\n",
            "[01:23:28.320 --> 01:23:29.360] 我倒反而觉得\n",
            "[01:23:29.360 --> 01:23:30.880] 可能未必那么有共识\n",
            "[01:23:30.920 --> 01:23:33.840] 真正对有价值的点\n",
            "[01:23:34.240 --> 01:23:36.120] 今天是不是真的浮现出来了\n",
            "[01:23:36.160 --> 01:23:37.800] 我其实还不好说\n",
            "[01:23:38.000 --> 01:23:38.600] 个人觉得\n",
            "[01:23:38.600 --> 01:23:40.280] 现在我们看到的边界\n",
            "[01:23:40.280 --> 01:23:42.360] 大部分都是模型本身的边界\n",
            "[01:23:42.360 --> 01:23:44.280] 就是说刚才俊宇说的那些的问题\n",
            "[01:23:44.280 --> 01:23:46.960] 都是因为GPT\n",
            "[01:23:46.960 --> 01:23:48.880] 他自己不支持的那些能力\n",
            "[01:23:49.360 --> 01:23:51.600] 基于他上面去做开发的\n",
            "[01:23:51.640 --> 01:23:52.600] 调用他API的\n",
            "[01:23:52.600 --> 01:23:54.760] 所以也没办法去更深的满足\n",
            "[01:23:54.960 --> 01:23:55.760] 譬如说\n",
            "[01:23:55.800 --> 01:23:58.360] 俊宇对于个人知识助手的\n",
            "[01:23:58.360 --> 01:23:59.400] 这样的一个需求\n",
            "[01:23:59.880 --> 01:24:00.920] 那个可以hack出来\n",
            "[01:24:00.960 --> 01:24:02.680] 我觉得还是应该可以hack出来\n",
            "[01:24:03.120 --> 01:24:05.080] 但说到说所有的东西都再做一遍\n",
            "[01:24:05.160 --> 01:24:07.880] 我觉得这个也还是有一个小的坑\n",
            "[01:24:08.040 --> 01:24:09.240] 因为如果我们想象\n",
            "[01:24:09.240 --> 01:24:11.000] 移动互联网的这十几年\n",
            "[01:24:11.680 --> 01:24:12.480] 其实互联网\n",
            "[01:24:12.480 --> 01:24:13.720] 就同样的逻辑\n",
            "[01:24:13.720 --> 01:24:15.000] 互联网上所有的东西\n",
            "[01:24:15.000 --> 01:24:16.920] 在移动互联网再做一遍\n",
            "[01:24:17.160 --> 01:24:19.080] 其实这事最后把它真的做成了\n",
            "[01:24:19.080 --> 01:24:21.760] 都还是传统的桌面互联网的老兵\n",
            "[01:24:22.400 --> 01:24:22.720] 对\n",
            "[01:24:22.720 --> 01:24:24.640] 比如说即时通讯还是被腾讯做了\n",
            "[01:24:24.880 --> 01:24:27.720] 比如说搜索也没有出现一个新的搜索\n",
            "[01:24:27.720 --> 01:24:29.320] 在美国社交暂时来讲\n",
            "[01:24:29.320 --> 01:24:31.320] 也还是Facebook\n",
            "[01:24:32.480 --> 01:24:33.720] 你在移动互联网\n",
            "[01:24:33.720 --> 01:24:34.840] 在移动互联网上面\n",
            "[01:24:34.840 --> 01:24:36.440] 真的能跑出来的新公司\n",
            "[01:24:36.720 --> 01:24:37.880] 其实是传统互联网\n",
            "[01:24:37.880 --> 01:24:39.560] 桌面互联网上面其实不太存在\n",
            "[01:24:40.440 --> 01:24:42.920] 我同意俊宇说的\n",
            "[01:24:43.040 --> 01:24:44.400] 就是我们可以推理\n",
            "[01:24:44.400 --> 01:24:47.440] 就从互联网时代迁移到移动互联网的\n",
            "[01:24:47.440 --> 01:24:48.760] 中间当然也有掉队的\n",
            "[01:24:49.120 --> 01:24:50.720] 我们就不点名谁掉队了\n",
            "[01:24:50.880 --> 01:24:53.120] 但是还是有很多互联网时代的巨头\n",
            "[01:24:53.120 --> 01:24:53.960] 迁移过来了\n",
            "[01:24:54.120 --> 01:24:56.560] 我认为这一次的成功迁移率\n",
            "[01:24:56.560 --> 01:24:58.400] 只会比上次更高\n",
            "[01:24:58.400 --> 01:24:59.480] 而不会更低\n",
            "[01:24:59.480 --> 01:24:59.720] 对\n",
            "[01:24:59.720 --> 01:25:02.040] 所以说白了留给创业者的机会\n",
            "[01:25:02.040 --> 01:25:05.280] 不是像你想象的广阔天地任你作为\n",
            "[01:25:05.280 --> 01:25:08.680] 是能给你留的天地很广阔\n",
            "[01:25:08.680 --> 01:25:10.200] 但你能折腾的天地\n",
            "[01:25:10.200 --> 01:25:11.200] 它未必那么广阔\n",
            "[01:25:11.200 --> 01:25:13.080] 因为巨头大部分都会过来\n",
            "[01:25:13.080 --> 01:25:17.720] 所以你如何把你的有限的能力时间和资源\n",
            "[01:25:17.720 --> 01:25:20.920] 找到卑躬实地点真正做透\n",
            "[01:25:20.920 --> 01:25:23.760] 我觉得其实真说大机会是在这\n",
            "[01:25:23.920 --> 01:25:26.960] 真说热闹就是现在你就看见这个API\n",
            "[01:25:26.960 --> 01:25:27.960] 咱就可以玩起来\n",
            "[01:25:27.960 --> 01:25:28.400] 对吧\n",
            "[01:25:28.400 --> 01:25:31.560] 所以这种就是看你要怎么抓这个机会\n",
            "[01:25:31.560 --> 01:25:34.200] 这个也考验你对这件事的理解的深度\n",
            "[01:25:34.200 --> 01:25:37.400] 甚至深度到你能判断这个事儿好有意思\n",
            "[01:25:37.400 --> 01:25:37.920] 值得做\n",
            "[01:25:37.920 --> 01:25:39.640] 但是不是该你做\n",
            "[01:25:39.640 --> 01:25:43.560] 是不是你做了其实是给大厂在做产品经理\n",
            "[01:25:43.560 --> 01:25:43.920] 对吧\n",
            "[01:25:43.920 --> 01:25:45.320] 再去做演示\n",
            "[01:25:45.320 --> 01:25:47.400] 这个一样会是需要考虑的\n",
            "[01:25:48.000 --> 01:25:48.280] 对\n",
            "[01:25:48.280 --> 01:25:49.880] 我表达一下我的不同观点\n",
            "[01:25:49.880 --> 01:25:52.000] 就是我说的不同\n",
            "[01:25:52.000 --> 01:25:54.240] 是不和你们有什么不同\n",
            "[01:25:54.240 --> 01:25:57.320] 只是我是觉得巨头会在很长一段时间内\n",
            "[01:25:57.320 --> 01:26:00.320] 经历都得每家得出个大模型\n",
            "[01:26:00.320 --> 01:26:03.120] 如果他们自己不出大模型就会被淘汰掉\n",
            "[01:26:03.120 --> 01:26:05.120] 这是一个非常现实\n",
            "[01:26:05.120 --> 01:26:06.760] 就刚刚大家在问腾讯怎么样\n",
            "[01:26:06.760 --> 01:26:08.240] 我觉得腾讯它也必然会出\n",
            "[01:26:08.240 --> 01:26:10.760] 只是可能我会觉得它会稍微慢一点\n",
            "[01:26:10.760 --> 01:26:13.400] 因为它毕竟有基础设施在那里\n",
            "[01:26:13.400 --> 01:26:17.280] 就现在我的比喻是叫做巨头之间的核战争开始了\n",
            "[01:26:17.280 --> 01:26:20.120] 就你帮伊安有1000万美军训练费下去了\n",
            "[01:26:20.120 --> 01:26:21.360] 我这里也得来1000万\n",
            "[01:26:21.360 --> 01:26:23.080] 我完了我得2000万美金\n",
            "[01:26:23.080 --> 01:26:23.720] 对吧\n",
            "[01:26:23.720 --> 01:26:25.160] 这个一定是这样\n",
            "[01:26:25.160 --> 01:26:27.000] 它不会先从应用切的\n",
            "[01:26:27.000 --> 01:26:29.360] 因为它切一个应用切出多少用户了\n",
            "[01:26:29.360 --> 01:26:31.880] 你不能想象它用的是Chad GPT吧\n",
            "[01:26:31.880 --> 01:26:35.360] 你也不能想象这个腾讯东西用文心一言吧\n",
            "[01:26:35.360 --> 01:26:36.360] 对吧\n",
            "[01:26:36.360 --> 01:26:39.120] 或者你那个头条都已经构建了\n",
            "[01:26:39.120 --> 01:26:42.440] 所以他们现在必然是要在这里去全力以赴的\n",
            "[01:26:42.440 --> 01:26:42.960] 好\n",
            "[01:26:42.960 --> 01:26:43.480] 这是第一个\n",
            "[01:26:43.480 --> 01:26:46.920] 第二个就是后来者他就必然要更开放\n",
            "[01:26:46.920 --> 01:26:49.320] 他不开放他已经落后了\n",
            "[01:26:49.320 --> 01:26:49.680] 对吧\n",
            "[01:26:49.680 --> 01:26:52.680] Chad GPT的GPT 4.0是半年前做的\n",
            "[01:26:52.680 --> 01:26:53.480] 就已经做完了\n",
            "[01:26:53.480 --> 01:26:56.040] 他们这个在发布之前我就听过\n",
            "[01:26:56.040 --> 01:26:56.760] 我也很震惊\n",
            "[01:26:56.760 --> 01:26:59.600] 就是他5.0也在做了\n",
            "[01:26:59.600 --> 01:26:59.840] 对吧\n",
            "[01:26:59.840 --> 01:27:02.320] 这时候他反而他前面已经开放了\n",
            "[01:27:02.320 --> 01:27:04.720] 那后面就会就你赶快帮我做应用\n",
            "[01:27:04.720 --> 01:27:08.320] 一定要他要笼络后面的人一定要笼络开发者\n",
            "[01:27:08.320 --> 01:27:12.000] 他不再笼络开发者被一家给全收割完了\n",
            "[01:27:12.000 --> 01:27:12.240] 对吧\n",
            "[01:27:12.240 --> 01:27:14.600] 可能有的巨头动作会慢一点会那个一点\n",
            "[01:27:14.600 --> 01:27:17.200] 所以他会给应用一个时间的\n",
            "[01:27:17.200 --> 01:27:18.240] 我认为这一次呢\n",
            "[01:27:18.240 --> 01:27:21.800] 就是因为巨头在手机上的操作系统这事\n",
            "[01:27:21.800 --> 01:27:23.560] 大家还没有太多的那个对吧\n",
            "[01:27:23.560 --> 01:27:24.640] 有几个干过的\n",
            "[01:27:24.640 --> 01:27:26.400] 那干不过谷歌也就无所谓了\n",
            "[01:27:26.400 --> 01:27:28.560] 应用层这个分层非常明显\n",
            "[01:27:28.560 --> 01:27:31.120] 现在这个大模型这个事儿\n",
            "[01:27:31.120 --> 01:27:35.160] 就是没有大模型的巨头都要被淘汰掉了\n",
            "[01:27:35.160 --> 01:27:37.080] 就是比较明显\n",
            "[01:27:37.080 --> 01:27:38.280] 谁就带一帮小弟对吧\n",
            "[01:27:38.280 --> 01:27:39.160] 是谁跟我多\n",
            "[01:27:39.160 --> 01:27:42.840] 那所以我觉得应用还是会有一个挺大的机会的\n",
            "[01:27:44.840 --> 01:27:46.800] 巨头的淘汰赛开始了\n",
            "[01:27:48.240 --> 01:27:51.400] 在Openair和微软的联盟面前\n",
            "[01:27:51.400 --> 01:27:54.680] 所有巨头众生平等的落后了\n",
            "[01:27:54.680 --> 01:27:56.840] 所以基本就是这样吧\n",
            "[01:27:57.960 --> 01:27:59.040] 对\n",
            "[01:27:59.040 --> 01:27:59.360] 好\n",
            "[01:27:59.360 --> 01:28:01.720] 那今天我们就聊到这儿吧\n",
            "[01:28:01.720 --> 01:28:04.920] 感谢各位的时间和参与\n",
            "[01:28:04.920 --> 01:28:06.240] 好好感谢感谢\n",
            "[01:28:06.240 --> 01:28:08.120] 好好好\n",
            "[01:28:08.120 --> 01:28:09.160] 好谢谢谢谢\n",
            "[01:28:09.160 --> 01:28:09.920] 展鹏\n",
            "[01:28:09.920 --> 01:28:10.440] 拜拜\n",
            "[01:28:10.440 --> 01:28:11.320] 拜拜\n",
            "[01:28:11.320 --> 01:28:12.720] 拜拜\n",
            "[01:28:14.040 --> 01:28:15.920] OK今天就先聊到这边\n",
            "[01:28:15.920 --> 01:28:19.000] 大家可以订阅点赞评论分享\n",
            "[01:28:19.000 --> 01:28:20.920] 如果还有什么想听我说的\n",
            "[01:28:20.920 --> 01:28:23.160] 欢迎在评论区互动留言\n",
            "[01:28:23.160 --> 01:28:24.560] 我们下期见\n"
          ]
        },
        {
          "data": {
            "text/markdown": [
              "**Transcript file created: 108.跟傅盛和王俊煜聊：大模型、产品经理和热门AI应‪用‬.srt**"
            ],
            "text/plain": [
              "<IPython.core.display.Markdown object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "#@markdown # **Run the model** 🚀\n",
        "\n",
        "#@markdown Run this cell to execute the transcription of the video. This can take a while and very based on the length of the video and the number of parameters of the model selected above.\n",
        "\n",
        "#@markdown ## **Parameters** ⚙️\n",
        "\n",
        "#@markdown ### **Behavior control**\n",
        "#@markdown ---\n",
        "language = \"Auto detection\"  # @param ['Auto detection', 'Afrikaans', 'Albanian', 'Amharic', 'Arabic', 'Armenian', 'Assamese', 'Azerbaijani', 'Bashkir', 'Basque', 'Belarusian', 'Bengali', 'Bosnian', 'Breton', 'Bulgarian', 'Burmese', 'Castilian', 'Catalan', 'Chinese', 'Croatian', 'Czech', 'Danish', 'Dutch', 'English', 'Estonian', 'Faroese', 'Finnish', 'Flemish', 'French', 'Galician', 'Georgian', 'German', 'Greek', 'Gujarati', 'Haitian', 'Haitian Creole', 'Hausa', 'Hawaiian', 'Hebrew', 'Hindi', 'Hungarian', 'Icelandic', 'Indonesian', 'Italian', 'Japanese', 'Javanese', 'Kannada', 'Kazakh', 'Khmer', 'Korean', 'Lao', 'Latin', 'Latvian', 'Letzeburgesch', 'Lingala', 'Lithuanian', 'Luxembourgish', 'Macedonian', 'Malagasy', 'Malay', 'Malayalam', 'Maltese', 'Maori', 'Marathi', 'Moldavian', 'Moldovan', 'Mongolian', 'Myanmar', 'Nepali', 'Norwegian', 'Nynorsk', 'Occitan', 'Panjabi', 'Pashto', 'Persian', 'Polish', 'Portuguese', 'Punjabi', 'Pushto', 'Romanian', 'Russian', 'Sanskrit', 'Serbian', 'Shona', 'Sindhi', 'Sinhala', 'Sinhalese', 'Slovak', 'Slovenian', 'Somali', 'Spanish', 'Sundanese', 'Swahili', 'Swedish', 'Tagalog', 'Tajik', 'Tamil', 'Tatar', 'Telugu', 'Thai', 'Tibetan', 'Turkish', 'Turkmen', 'Ukrainian', 'Urdu', 'Uzbek', 'Valencian', 'Vietnamese', 'Welsh', 'Yiddish', 'Yoruba']\n",
        "#@markdown > Language spoken in the audio, use `Auto detection` to let Whisper detect the language.\n",
        "#@markdown ---\n",
        "verbose = 'Live transcription' #@param ['Live transcription', 'Progress bar', 'None']\n",
        "#@markdown > Whether to print out the progress and debug messages.\n",
        "#@markdown ---\n",
        "output_format = 'srt' #@param ['txt', 'vtt', 'srt', 'tsv', 'json', 'all']\n",
        "#@markdown > Type of file to generate to record the transcription.\n",
        "#@markdown ---\n",
        "task = 'transcribe' #@param ['transcribe', 'translate']\n",
        "#@markdown > Whether to perform X->X speech recognition (`transcribe`) or X->English translation (`translate`).\n",
        "#@markdown ---\n",
        "\n",
        "#@markdown \n",
        "\n",
        "#@markdown ### **Optional: Fine tunning** \n",
        "#@markdown ---\n",
        "temperature = 0.15 #@param {type:\"slider\", min:0, max:1, step:0.05}\n",
        "#@markdown > Temperature to use for sampling.\n",
        "#@markdown ---\n",
        "temperature_increment_on_fallback = 0.2 #@param {type:\"slider\", min:0, max:1, step:0.05}\n",
        "#@markdown > Temperature to increase when falling back when the decoding fails to meet either of the thresholds below.\n",
        "#@markdown ---\n",
        "best_of = 5 #@param {type:\"integer\"}\n",
        "#@markdown > Number of candidates when sampling with non-zero temperature.\n",
        "#@markdown ---\n",
        "beam_size = 8 #@param {type:\"integer\"}\n",
        "#@markdown > Number of beams in beam search, only applicable when temperature is zero.\n",
        "#@markdown ---\n",
        "patience = 1.0 #@param {type:\"number\"}\n",
        "#@markdown > Optional patience value to use in beam decoding, as in [*Beam Decoding with Controlled Patience*](https://arxiv.org/abs/2204.05424), the default (1.0) is equivalent to conventional beam search.\n",
        "#@markdown ---\n",
        "length_penalty = -0.05 #@param {type:\"slider\", min:-0.05, max:1, step:0.05}\n",
        "#@markdown > Optional token length penalty coefficient (alpha) as in [*Google's Neural Machine Translation System*](https://arxiv.org/abs/1609.08144), set to negative value to uses simple length normalization.\n",
        "#@markdown ---\n",
        "suppress_tokens = \"-1\" #@param {type:\"string\"}\n",
        "#@markdown > Comma-separated list of token ids to suppress during sampling; '-1' will suppress most special characters except common punctuations.\n",
        "#@markdown ---\n",
        "initial_prompt = \"\" #@param {type:\"string\"}\n",
        "#@markdown > Optional text to provide as a prompt for the first window.\n",
        "#@markdown ---\n",
        "condition_on_previous_text = True #@param {type:\"boolean\"}\n",
        "#@markdown > if True, provide the previous output of the model as a prompt for the next window; disabling may make the text inconsistent across windows, but the model becomes less prone to getting stuck in a failure loop.\n",
        "#@markdown ---\n",
        "fp16 = True #@param {type:\"boolean\"}\n",
        "#@markdown > whether to perform inference in fp16.\n",
        "#@markdown ---\n",
        "compression_ratio_threshold = 2.4 #@param {type:\"number\"}\n",
        "#@markdown > If the gzip compression ratio is higher than this value, treat the decoding as failed.\n",
        "#@markdown ---\n",
        "logprob_threshold = -1.0 #@param {type:\"number\"}\n",
        "#@markdown > If the average log probability is lower than this value, treat the decoding as failed.\n",
        "#@markdown ---\n",
        "no_speech_threshold = 0.6 #@param {type:\"slider\", min:-0.0, max:1, step:0.05}\n",
        "#@markdown > If the probability of the <|nospeech|> token is higher than this value AND the decoding has failed due to `logprob_threshold`, consider the segment as silence.\n",
        "#@markdown ---\n",
        "\n",
        "verbose_lut = {\n",
        "    'Live transcription': True,\n",
        "    'Progress bar': False,\n",
        "    'None': None\n",
        "}\n",
        "\n",
        "import numpy as np\n",
        "import warnings\n",
        "import shutil\n",
        "from pathlib import Path\n",
        "\n",
        "args = dict(\n",
        "    language = (None if language == \"Auto detection\" else language),\n",
        "    verbose = verbose_lut[verbose],\n",
        "    task = task,\n",
        "    temperature = temperature,\n",
        "    temperature_increment_on_fallback = temperature_increment_on_fallback,\n",
        "    best_of = best_of,\n",
        "    beam_size = beam_size,\n",
        "    patience=patience,\n",
        "    length_penalty=(length_penalty if length_penalty>=0.0 else None),\n",
        "    suppress_tokens=suppress_tokens,\n",
        "    initial_prompt=(None if not initial_prompt else initial_prompt),\n",
        "    condition_on_previous_text=condition_on_previous_text,\n",
        "    fp16=fp16,\n",
        "    compression_ratio_threshold=compression_ratio_threshold,\n",
        "    logprob_threshold=logprob_threshold,\n",
        "    no_speech_threshold=no_speech_threshold\n",
        ")\n",
        "\n",
        "temperature = args.pop(\"temperature\")\n",
        "temperature_increment_on_fallback = args.pop(\"temperature_increment_on_fallback\")\n",
        "if temperature_increment_on_fallback is not None:\n",
        "    temperature = tuple(np.arange(temperature, 1.0 + 1e-6, temperature_increment_on_fallback))\n",
        "else:\n",
        "    temperature = [temperature]\n",
        "\n",
        "if Model.endswith(\".en\") and args[\"language\"] not in {\"en\", \"English\"}:\n",
        "    warnings.warn(f\"{Model} is an English-only model but receipted '{args['language']}'; using English instead.\")\n",
        "    args[\"language\"] = \"en\"\n",
        "\n",
        "display(Markdown(f\"### {filepath}\"))\n",
        "\n",
        "audio_path_local = Path(filepath).resolve()\n",
        "print(\"audio local path:\", audio_path_local)\n",
        "\n",
        "transcription = whisper.transcribe(\n",
        "    whisper_model,\n",
        "    str(audio_path_local),\n",
        "    temperature=temperature,\n",
        "    **args,\n",
        ")\n",
        "\n",
        "# Save output\n",
        "whisper.utils.get_writer(\n",
        "    output_format=output_format,\n",
        "    output_dir=audio_path_local.parent\n",
        ")(\n",
        "    transcription,\n",
        "    title\n",
        ")\n",
        "\n",
        "try:\n",
        "    if output_format==\"all\":\n",
        "        for ext in ('txt', 'vtt', 'srt', 'tsv', 'json'):\n",
        "            transcript_file_name = title + \".\" + ext\n",
        "            display(Markdown(f\"**Transcript file created: {transcript_file_name}**\"))\n",
        "    else:\n",
        "        transcript_file_name = title + \".\" + output_format\n",
        "\n",
        "        display(Markdown(f\"**Transcript file created: {transcript_file_name}**\"))\n",
        "\n",
        "except:\n",
        "    display(Markdown(f\"**Transcript file created: {transcript_local_path}**\"))\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 46
        },
        "id": "yBGKpOjFHLTx",
        "outputId": "cd1013fc-4d14-4e71-9a92-6a9a7083749d"
      },
      "outputs": [
        {
          "data": {
            "text/markdown": [
              "**Download: 108.跟傅盛和王俊煜聊：大模型、产品经理和热门AI应‪用‬.srt**"
            ],
            "text/plain": [
              "<IPython.core.display.Markdown object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "application/javascript": "\n    async function download(id, filename, size) {\n      if (!google.colab.kernel.accessAllowed) {\n        return;\n      }\n      const div = document.createElement('div');\n      const label = document.createElement('label');\n      label.textContent = `Downloading \"${filename}\": `;\n      div.appendChild(label);\n      const progress = document.createElement('progress');\n      progress.max = size;\n      div.appendChild(progress);\n      document.body.appendChild(div);\n\n      const buffers = [];\n      let downloaded = 0;\n\n      const channel = await google.colab.kernel.comms.open(id);\n      // Send a message to notify the kernel that we're ready.\n      channel.send({})\n\n      for await (const message of channel.messages) {\n        // Send a message to notify the kernel that we're ready.\n        channel.send({})\n        if (message.buffers) {\n          for (const buffer of message.buffers) {\n            buffers.push(buffer);\n            downloaded += buffer.byteLength;\n            progress.value = downloaded;\n          }\n        }\n      }\n      const blob = new Blob(buffers, {type: 'application/binary'});\n      const a = document.createElement('a');\n      a.href = window.URL.createObjectURL(blob);\n      a.download = filename;\n      div.appendChild(a);\n      a.click();\n      div.remove();\n    }\n  ",
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "application/javascript": "download(\"download_51f8174c-28fa-48bb-9c00-695457038411\", \"108.\\u8ddf\\u5085\\u76db\\u548c\\u738b\\u4fca\\u715c\\u804a\\uff1a\\u5927\\u6a21\\u578b\\u3001\\u4ea7\\u54c1\\u7ecf\\u7406\\u548c\\u70ed\\u95e8AI\\u5e94\\u202a\\u7528\\u202c.srt\", 173530)",
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "#@markdown # **Download the subtitle file** 🎆\n",
        "\n",
        "from google.colab import files\n",
        "\n",
        "output_dir = str(audio_path_local.parent)\n",
        "\n",
        "if output_format==\"all\":\n",
        "    for ext in ('txt', 'vtt', 'srt', 'tsv', 'json'):\n",
        "        transcript_file_name = audio_path_local.stem + \".\" + ext\n",
        "        display(Markdown(f\"**Download: {transcript_file_name}**\"))\n",
        "        files.download(output_dir + \"/\" + transcript_file_name)\n",
        "else:\n",
        "    transcript_file_name = audio_path_local.stem + \".\" + output_format\n",
        "\n",
        "    display(Markdown(f\"**Download: {transcript_file_name}**\"))\n",
        "    files.download(output_dir + \"/\" + transcript_file_name)\n"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": []
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}