NALU-Language-Calculator.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_alph_dict = {0: 'zero', 1:'one', 2:'two', 3:'three', 4:'four', 5:'five', 6:'six', 7:'seven', 8:'eight', 9: 'nine',\n",
    "                10:'ten', 11:'eleven', 12:'twelve', 13:'thirteen', 14:'fourteen', 15:'fifteen', 16:'sixteen',\n",
    "                17:'seventeen', 18:'eighteen', 19:'nineteen', 20:'twenty', 30:'thirty', 40:'fourty', 50:'fifty',\n",
    "                60:'sixty', 70:'seventy', 80:'eighty', 90:'ninety', 100:'hundred', 1000:'thousand'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [],
   "source": [
    "alph_num_dict = {v: k  for k,v in num_alph_dict.items()}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [],
   "source": [
    "def alph2num(string):\n",
    "    res = 0\n",
    "    num_numbers = len(string.split(' '))\n",
    "    mult = 1\n",
    "    if num_numbers==1:\n",
    "        return alph_num_dict[string]\n",
    "    for word in reversed(string.split(' ')):\n",
    "        if word == 'and':\n",
    "            continue\n",
    "        if alph_num_dict[word] in [100, 1000]:\n",
    "            mult = alph_num_dict[word]*mult\n",
    "        elif mult!=1:\n",
    "            res += mult * alph_num_dict[word]\n",
    "            mult = 1\n",
    "        else:\n",
    "            res += alph_num_dict[word]\n",
    "    return res\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [],
   "source": [
    "def num2alph(num):\n",
    "    res = []\n",
    "    div = 10\n",
    "    for div in reversed([100, 1000]):\n",
    "        q = num//div\n",
    "        if q==0:\n",
    "            continue\n",
    "        if 0<q<=9:\n",
    "            res.extend([num_alph_dict[q], num_alph_dict[div]])\n",
    "        else:\n",
    "            res.extend(num2alph(q).split(' '))\n",
    "            res.append(num_alph_dict[div])\n",
    "        num = num - q * div\n",
    "    if num<=20:\n",
    "        res.append(num_alph_dict[num])\n",
    "        return ' '.join(res)\n",
    "    q = num//10\n",
    "    if q!=0:\n",
    "        res.append(num_alph_dict[q*10])\n",
    "    num = num - q * 10\n",
    "    if num!=0:\n",
    "        res.append(num_alph_dict[num])\n",
    "    \n",
    "    return ' '.join(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_data(start, end, size, train = False):\n",
    "    numbers1 = np.random.randint(start, end, size)\n",
    "    numbers2 = np.random.randint(start, end, size)\n",
    "    if train:\n",
    "        numbers1 = np.random.permutation(np.append(numbers1, list(num_alph_dict.keys())))\n",
    "        numbers2 = np.random.permutation(np.append(numbers2, list(num_alph_dict.keys())))\n",
    "    alphs = []\n",
    "    results = []\n",
    "    ops = ['times', 'plus', 'minus', 'divided_by']\n",
    "    for num1, num2 in zip(numbers1, numbers2):\n",
    "        op = random.choice(ops)\n",
    "        alphs.append(num2alph(num1)+ ' ' + op + ' ' + num2alph(num2))\n",
    "        if op == 'times':\n",
    "            results.append(float(num1) * float(num2))\n",
    "        elif op == 'plus':\n",
    "            results.append(num1 + num2)\n",
    "        elif op == 'minus':\n",
    "            results.append(num1 - num2)\n",
    "        elif op == 'divided_by':\n",
    "            results.append(num1 / num2)\n",
    "         \n",
    "    return alphs, results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_tr, y_tr = get_data(1, 1000, 10000, True)\n",
    "x_tst, y_tst = get_data(1, 1000, 1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}