CodingAI6-student-code.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Code for CodingAI Lesson 6 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Programming topics for competition I"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Importing modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "print(math.pi > math.sqrt(10))\n",
    "print(math.sqrt(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "random.random()\t# generate a random number from [0, 1)\n",
    "random.randint(10, 16)\t# generate a random integer between [a, b]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [0, 1, 3]\n",
    "random.sample(x, k=2)  # return a list of k elements, without replacement\n",
    "random.choices(x, k=2)  # return a list of k elements, with replacement\n",
    "\n",
    "print(\"Without replacement..\")\n",
    "for i in range(5):\n",
    "    print(random.sample(x, k=2))\n",
    "\n",
    "print(\"With replacement..\")\n",
    "for i in range(5):\n",
    "    print(random.choices(x, k=2))\n",
    "\n",
    "print(random.choice(x))        # return an element of x\n",
    "print(random.choices(x, k=1))  # return a list with 1 element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random as rd\n",
    "\n",
    "rd.randint(10, 16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "params = {'face': 'true', 'gender': False, 3: 'Hello', 'apple': 'good'}\n",
    "print(params)\n",
    "\n",
    "params = {\n",
    "        'face': 'true', \n",
    "        'gender': False,\n",
    "        3: 'Hello',\n",
    "        'apple': 'good' \n",
    "}\n",
    "print(params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(params['face'])   # access the value corresponded to the key face\n",
    "params['face'] = 4      # modify value \n",
    "print(params['face'])\n",
    "print(params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "params['hands'] = 2\n",
    "print(params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(len(params))          # len() counts the number of keys in the dictionary\n",
    "print(3 in params)\n",
    "print('apple' in params)   # the in operator checks if 'apple' is one of params’ key\n",
    "print('applE' in params)\n",
    "print('good' in params)    # 'good' is a value, so not in keys of params"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for key, value in params.items():\n",
    "    print(key)\n",
    "    print(value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = {\n",
    "     'param1': [1, 2, 5, 10],\n",
    "     'param2': [1, 3, 5, 7, 9], \n",
    "     'param3': {\n",
    "             'word1': 'Hello',\n",
    "             'word2': 'World',\n",
    "             'num': 10,\n",
    "             'secret': [True, False, True]\n",
    "             }\n",
    "     }\n",
    "     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(len(x))            # is this what you expected?\n",
    "print(x['param2'])\n",
    "print(len(x['param2']))  # is this what you expected?\n",
    "print(len(x['param3']))  # is this what you expected?\n",
    "print(x['param2'][3])\n",
    "print(x['param3']['word2'])\n",
    "print(x['param3']['secret'][0])\n",
    "print(1 in x)\n",
    "print(1 in x['param1'])\n",
    "print('num' in x)\n",
    "print('num' in x['param3'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for k, v in x.items():\n",
    "    print(k)\n",
    "    print(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for k, v in x['param3'].items():\n",
    "    print(k)\n",
    "    print(v)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dict = {\n",
    "        'a': 'c',\n",
    "        'b': 'd',\n",
    "        'c': 'e',\n",
    "        'd': 'f'\n",
    "        }\n",
    "\n",
    "my_letters = ['b', 'b', 'c', 'a', 'd']\n",
    "\n",
    "print('original input: ')\n",
    "for v in my_letters:\n",
    "    print(v)\n",
    "    \n",
    "print('translated output: ')\n",
    "for v in my_letters:\n",
    "    print(my_dict[v])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise: Programming topics for competition I"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Programming topics for competition II"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this section we discuss the 5 FSAI APIs. Each API follows the the same format:\n",
    "    - FSAI API function body, which you probably don't need to modify\n",
    "    - Examples of using the API"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests\n",
    "import base64\n",
    "import ast"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use your personal key. \n",
    "my_account_key = 'dummy'\n",
    "\n",
    "# The folder that contains some files for testing below\n",
    "file_dir = 'C:/Users/k/Desktop/FSAI/'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Speech-to-text"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For this example to work, you will need to have an audio file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def speech_to_text(key, file_path):\n",
    "    api_addr = 'https://apiplug.findsolutionwebsvc.com/v1/convos/stt?language=zh-HK'\n",
    "    headers = {\n",
    "            'Content-Type':'audio/wav',\n",
    "            'Accept': 'audio/wav',\n",
    "           # 'Authorization': key,\n",
    "    }\n",
    "    with open(file_path, 'rb') as file_handler:\n",
    "        req_body = file_handler.read()\n",
    "\n",
    "    response = requests.post(api_addr, headers=headers, data=req_body)\n",
    "    if response.status_code == 200:\n",
    "        return True, ast.literal_eval(response.text)\n",
    "    else:\n",
    "        return False, None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the file path to the audio file\n",
    "my_audio = file_dir + 'apple.wav'\n",
    "\n",
    "# calling the API\n",
    "success, result = speech_to_text(my_account_key, my_audio)\n",
    "\n",
    "# result\n",
    "if success:\n",
    "    print(result['DisplayText'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Text-to-Speech"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For this example,\n",
    "1. if you receive a 'FileNotFoundError', probably because you have not\n",
    "   created the folder specified by my_folder\n",
    "        \n",
    "2. if you receive a 'PermissionError', usually because you are playing the\n",
    " file (eg. in windows media player). Close windows media player and re-run."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def text_to_speech(key, input_text, source_lang):\n",
    "    api_addr = 'https://apiplug.findsolutionwebsvc.com/v1/convos/tts'\n",
    "    headers = {\n",
    "            'Content-Type': 'application/json',\n",
    "           # 'Authorization': key,\n",
    "    }\n",
    "    req_body = {\n",
    "        'provider': 'MS',\n",
    "        'data': {\n",
    "            'text': input_text,\n",
    "            'source': source_lang,\n",
    "        }\n",
    "    }\n",
    "    response = requests.post(api_addr, headers=headers, json=req_body)\n",
    "    if response.status_code == 200:\n",
    "        return True, base64.b64decode(response.content)\n",
    "    else:\n",
    "        return False, None\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the text you want to convert to speech\n",
    "my_text = '床前明月光, 疑是地上霜.'\n",
    "\n",
    "# the output location for the audio file\n",
    "output_folder = file_dir\n",
    "\n",
    "# calling the API\n",
    "success, result = text_to_speech(my_account_key, my_text, 'zh-HK')\n",
    "\n",
    "# writing the audio file \n",
    "if success:\n",
    "    with open(output_folder + '01.wav', 'wb') as audio:\n",
    "        audio.write(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_text = 'Mathematics is essential in many fields such as natural sciences.'\n",
    "output_folder = file_dir\n",
    "success, result = text_to_speech(my_account_key, my_text, 'en-US')\n",
    "\n",
    "if success:\n",
    "    with open(output_folder + '02.wav', 'wb') as audio:\n",
    "        audio.write(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Translation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def translate_text(key, input_text, source_lang, target_lang):\n",
    "    api_addr = 'https://apiplug.findsolutionwebsvc.com/v1/langs/translate'\n",
    "    headers = {\n",
    "            'Content-Type':'application/json',\n",
    "           # 'Authorization': key,\n",
    "    }\n",
    "    req_body = {\n",
    "            'provider': 'Google',\n",
    "            'data': {\n",
    "                    'text': input_text,\n",
    "                    'target': target_lang,\n",
    "                    'source': source_lang\n",
    "                    }\n",
    "            }\n",
    "    response = requests.post(api_addr, headers=headers, json=req_body)\n",
    "    if response.status_code != 200:\n",
    "        return False, None\n",
    "    result = ast.literal_eval(response.text)\n",
    "    if result['code'] == '200':\n",
    "        outcome = result['data']['details']['data']['translations']\n",
    "        return True, outcome[0]['translatedText']\n",
    "    else:\n",
    "        return False, None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the text you want to translate\n",
    "my_text = 'if you don\"t tell me what you want, how would i know what you want?'\n",
    "\n",
    "# calling the API\n",
    "success, result = translate_text(my_account_key, my_text, 'en', 'zh-TW')\n",
    "\n",
    "# printing the result\n",
    "if success:\n",
    "    print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_text = '煌めく瞬間に捕われ'\n",
    "success, result = translate_text(my_account_key, my_text, 'ja', 'en')\n",
    "if success:\n",
    "    print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sentiment Analysis\n",
    "\n",
    "Sentiment Analysis means whether the input text is positive or negative.<br>\n",
    "The output score is between -1 to 1. <br>\n",
    "1 means very positive; -1 means very negative; 0 means neutral."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_sentiment(key, input_text, source_lang):\n",
    "    api_addr = 'https://apiplug.findsolutionwebsvc.com/v1/langs/nlp'\n",
    "    headers = {\n",
    "            'Content-Type':'application/json',\n",
    "           # 'Authorization': key,\n",
    "    }\n",
    "    req_body = {\n",
    "            'provider': 'Google',\n",
    "            'data': {\n",
    "                    'text': input_text,\n",
    "                    'source': source_lang\n",
    "                    }\n",
    "            }\n",
    "    response = requests.post(api_addr, headers=headers, json=req_body)\n",
    "    if response.status_code != 200:\n",
    "        return False, None\n",
    "    result = ast.literal_eval(response.text)\n",
    "    if result['code'] == '200':\n",
    "        outcome = result['data']['details']['documentSentiment']\n",
    "        return True, outcome['score']\n",
    "    else:\n",
    "        return False, None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the text you want to get sentiments from\n",
    "my_text = 'i don\"t like strawberry ice-cream'\n",
    "\n",
    "# calling the API\n",
    "success, result = get_sentiment(my_account_key, my_text, 'en')\n",
    "\n",
    "# printing the result\n",
    "if success:\n",
    "    print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_text = '學習人工智能有助我們對未來的了解.'\n",
    "success, result = get_sentiment(my_account_key, my_text, 'zh')\n",
    "if success:\n",
    "    print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above 4 APIs are relatively straight forward. The hardest is the Image Recognition API.\n",
    "Because the API returns a lot of information. I don't know what information you want. So you \n",
    "probably have to write some code to accomplish your goal. That's the reason we spent some time \n",
    "discussing dictionaries above!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Image Recognition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def image_recognition(key, file_path):\n",
    "    api_addr = 'https://apiplug.findsolutionwebsvc.com/v1/images/obj'\n",
    "    headers = {\n",
    "            'Content-Type': 'application/json',\n",
    "            #'Authorization': key,\n",
    "    }\n",
    "    with open(file_path, 'rb') as file_handler:\n",
    "        encoded_string = base64.b64encode(file_handler.read())\n",
    "        img_str = encoded_string.decode('UTF-8')\n",
    "    req_body = {\n",
    "            'provider': 'AWS',\n",
    "            'data': {\n",
    "                    'img': img_str\n",
    "                    }\n",
    "            }\n",
    "    response = requests.post(api_addr, headers=headers, json=req_body)\n",
    "    if response.status_code != 200:\n",
    "        return False, None\n",
    "    result = ast.literal_eval(response.text)\n",
    "    if result['code'] == '200':\n",
    "        outcome = result['data']['details']['Labels']\n",
    "        return True, outcome\n",
    "    else:\n",
    "        return False, None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the image to be processed\n",
    "my_image = file_dir + 'dog.jpg'\n",
    "\n",
    "# calling the API\n",
    "success, result = image_recognition(my_account_key, my_image)\n",
    "\n",
    "# printing the result\n",
    "if success:\n",
    "    print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above output is very hard to understand. Python has a module called pretty print that can format\n",
    "the above nicely."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pprint\n",
    "\n",
    "pp = pprint.PrettyPrinter(indent=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pp.pprint(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each image can have very different outputs, depending what the computer sees in the image.\n",
    "A typical task is to see if certain objects appear in the image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# extract all the \"Name\"s from result\n",
    "\n",
    "objects_found = []\n",
    "\n",
    "for item in result:\n",
    "    objects_found.append(item['Name'])\n",
    "\n",
    "print(objects_found)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check if certain object is detected in the image\n",
    "\n",
    "object_name = 'Dog'\n",
    "\n",
    "if object_name in objects_found:\n",
    "    print(object_name + ' is in the image.')\n",
    "else:\n",
    "    print(object_name + ' is not in the image.')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}