Packative simplifies the creation of individual cardboard package design online

Packative

The Human Side of Animals: Chapter 12 - Tourists and Sight-seeing

What is So Good About the Ownership Economy?

¿Qué tiene de bueno la economía de propiedad?

Qu'y a-t-il de si bon dans l'économie de la propriété ?

स्वामित्व अर्थव्यवस्था के बारे में इतना अच्छा क्या है?

所有経済の何がそんなに良いのか?

O que há de tão bom na economia da propriedade?

Điều gì tốt về nền kinh tế sở hữu?

所有制经济有什么好处？

Astounding Stories of Super-Science June 1931, by Astounding Stories is part of HackerNoon’s Book Blog Post series. You can jump to any chapter in this book here . Manape the Mighty - Chapter II: Into the Jungle CHAPTER II. Into the Jungle They had to smile together at the results achieved with the bedraggled bits of cloth. Bentley suspected that they had been taken from bodies washed ashore as gruesome reminders of the catastrophe which had befallen the Bengal Queen, and because he did suspect this he did not ask questions that might cause Ellen to remember any longer than was necessary. Not that he doubted her courage, for she had proved that sufficiently; and she had proved that she was sensible, with none of the notions of the proprieties which would have made any other girl of Bentley's acquaintance a nuisance. Their next concern was food, which they must find in the jungle, or from other wreckage cast ashore from the Bengal Queen. Now, hand in hand—which seemed natural in the circumstances—they began to walk along the shore, heading into the north by mutual consent. As they walked Bentley kept pondering on that strange laughter he had heard and on the sound of savage drumming. The laughter puzzled him. If there were anyone in the jungle back of them, why had he or they failed to challenge them? As for the drumming sound—Bentley remembered what the second officer had said about this section of the coast. It was a bit of jungle inhabited by the great apes in large numbers. So, that drumming had been a challenge, the man-ape's manner of mocking an enemy by beating himself on his barrel chest with his huge fists. But that the ape had not been challenging Bentley and the girl Bentley felt quite sure, as the brute would certainly have shown himself in that case. They trudged on through the sand, while the sun beat down unmercifully on their uncovered heads. Ellen Estabrook strode along at Bentley's side without complaint. After perhaps an hour of this unbearable effort, when both felt as though the sun had sucked them dry of perspiration, they encountered a rough footpath leading into the jungle. The path suggested human habitation somewhere near. The inhabitants might be hostile natives, even cannibals perhaps, but in this unknown land they would have to take a chance on that. With a sigh of relief, and refusing to look ahead too far, or try to guess what lay in wait for them in the black mystery of the jungle, they turned into the footpath. The jungle was fetid and sweaty, but even this was a relief from the intolerable sun which could not reach them here because the jungle had closed its leafy arms over the trail instantly. One could not tell from the path whether it had been made by natives or by whites, for it was packed hard. It led straight away from the shoreline. "We'll have to keep a sharp lookout for possible poisoned spring darts, Ellen," said Bentley. "I'm not afraid, Lee," she answered stoutly. "Fate wouldn't allow us to come through what we have only to end things with poisoned darts. It just couldn't happen that way!" Thus simply they addressed each other. It seemed as though years had been squeezed into a matter of hours. They knew each other as well as they would, in other circumstances, have known each other after a year of constant association. Here barriers of conventions were razed as simply and naturally as among children. They had pressed well into the gloom of the jungle when the first sound came. Not the laughter they had heard before, but the drumming. It was ahead and somewhat to the left, and as they stopped without speaking they could distinctly hear the threshing of a huge body through the underbrush. The sound seemed to be approaching and for a minute or so they listened. Then the sound was repeated off to the right, a trifle further away. "Can you climb, Ellen?" asked Bentley simply. "This section is filled with anthropoid apes, according to the second officer of the Bengal Queen. We may have to take to the trees." "I can climb," she said, "but from what I've studied of the habits of these brutes they do a great deal of bluffing before they actually charge, and may not molest us at all if we pay no attention." Bentley felt almost nude because he had no weapons save his own fists. And he would not have admitted even to himself how deeply he was concerned over the girl. As far as he knew, this section might be entirely uninhabited. It might be given over entirely to the anthropoids. In this case he shuddered to think of what might happen to Ellen Estabrook if he were slain. He quickened his pace until Ellen kept stride with him with difficulty. The object uppermost in Bentley's mind was to get as far away as possible from the ominous drumbeats. They rounded a bend in the trail and stopped stock-still. Within fifty yards of them, blocking the trail, was a brute whose great size sent a thrill of horror through Bentley. It towered to the height of a big man, and must have weighed in the neighborhood of four hundred pounds. It was larger by far than any bull ape Bentley had seen in captivity. It had been waiting for them, silently, with almost human cunning; but now that it was discovered the shaggy creature rose to his hind legs and screamed a challenge, at the same time striking his chest with blows of his hairy fists which rolled in a dull booming of sound through the jungle. At the same time the creature moved forward. Bentley whirled to run, his hand clasping tighter the hand of Ellen Estabrook. But they had not retreated ten steps down the pathway when their way was blocked by another of the great shaggy brutes. And they could hear others on both sides. Bentley's face was chalk-white as he turned to the girl. Her calm acceptance of their predicament, an attitude in which he could read no slightest vestige of fear, helped him to regain control of his own nerves, which had threatened to send him into a panic. She even smiled, and Lee felt a trifle ashamed of himself. Now the crashing sounds were closing in. The two brutes before and behind on the trail were pressing in upon them. But no general headlong charge had yet begun. Bentley looked around him, seeking a tree with limbs low enough for them to reach and thus climb to safety. "There's one!" cried Ellen. Tugging at his hand she began to run. At the same moment the great apes bellowed and charged. But the charge was never finished, for through the drumming of their mighty fists on mighty barrel-like chests, through the sound of their charge, through the crackling underbrush came again that sound of laughter. There was fierce joy in the laughter, and the laughter was followed by words of a strange gibberish which Bentley could not recall as being from any language he had ever heard. The great apes paused. Out of the jungle to the right of the fugitives burst a white man. He was well past middle age, for his white hair hung almost to his shoulders, which were stooped with the weight of years. He was a wisp of a man whose smooth shaven face was apple-red. His eyes were black and expressionless as obsidian, and when Lee encountered the full gaze of them he was conscious of that feeling which he had experienced at various times in his life when he knew that some deadly reptile was close by. "Stand still a moment!" cried the old man. His voice was strangely high-pitched and cracked. From his right hand a whip with a long lash uncurled like a snake. This he swung back and hurled to the front, and the snap of it was like a pistol shot. The great ape on the path ahead cowered back, bearing his fangs, roaring in anger. But that he feared the whip of the old man was plain to be seen. The crashing sound in the jungle died away rapidly, immediately the first report of the whip lash sounded in the trail. Fearlessly the little man dashed upon the first of the great brutes the castaways had seen. His lash curled about the great beast's body, and the animal bellowed with pain. It clawed at the lash, but was not fast enough to capture it. In the end the brute broke and fled. The animal which had blocked their path in the rear had already disappeared. Now the little man came back to face the fugitives, and his lips were parted in a cordial smile. He coiled his whip and tucked it under his arm. He was dressed in well worn corduroy with high boots that were rather the worse for wear. Bentley saw that his lips were too red—like blood—and somehow he disliked the man instantly. "Welcome to Barterville," said the old man. "It has been years since I have seen any of my own kind. People avoid this section of the jungle." "I don't wonder," said Bentley, sighing deeply with relief. "Those brutes would make anybody keep away from here, if they knew about them. I thought they had us for a few minutes. They planned an ambush almost as well as human beings could have done it—but that's absurd of course, merely a coincidence." "Coincidence?" snapped the old man, a hint of asperity in his words. "Coincidence? I see you do not know the great apes, sir. I have always maintained that apes could be trained to do anything men can do. I have maintained that they have a language of their own, and even ways of communicating without words, a sort of jungle writing which men of course have never yet learned. I've devoted my life to learning the secrets of the great apes, their life histories, and so forth. I am Professor Caleb Barter!" "Professor Caleb Barter!" ejaculated Ellen Estabrook. "Why I've heard of him! He went on an expedition among the great apes ten years ago and was never heard of again." "I am Caleb Barter," said the old man. "I decided to disappear from the world I knew, to let other fool scientists think me dead in order that I might continue my investigations without molestation. And now I have almost reached the place where I can go back to civilization with information that will startle the world. There yet remains one experiment. Now I hope to make that experiment. No! No! Don't ask me what it is. It is my secret and nobody will ever wrest it from me." Bentley studied the old man. He seemed slightly demented, Bentley thought, but that might be merely the mental evolution of a man who had made a hermit of himself for so many years—if this chap actually were Professor Barter. "Professor Barter," went on Ellen, "was the scientific leader of his day. Others followed where he led. He made greater strides in surgery and medicine, and in unravelling the mysteries of evolution, than anyone else up to his time. Of course I believe you are Professor Barter. My name is Ellen Estabrook, and this gentleman is Lee Bentley. We believe ourselves to be the only survivors of the Bengal Queen. Perhaps you can lead us to food and water?" "Yes, oh yes! Indeed. One forgets how to be hospitable, I fear. I am sorry to hear there was a wreck and that lives were lost—but it may mean a great gain to the world of science. I am happier to see you than you can possibly know!" Bentley felt the cold chills racing along his spine as he listened to the old man's flow of words. He behaved well, but Bentley could feel in spite of that, that there was a hidden current of menace in the old man's behavior. He wished that Ellen would keep him talking, would somehow make sure of his identity. Perhaps the same thought was in her mind, for it had scarcely come to him when the girl spoke again. "Before he disappeared Professor Barter wrote a learned treatise on—" "I am Professor Barter, I tell you, young woman. But if you wish proof the title of the treatise was 'The Language of the Great Apes.'" Ellen turned quickly to Bentley and nodded. She was satisfied that the man was the person he claimed to be. He didn't ask how Ellen happened to know about him, and Bentley himself considered the proof entirely lacking in conclusiveness. Anyone might know about the last treatise of Barter. However, they could but await developments. They followed Barter along the trail. Now and again apes challenged from the jungle, and Barter answered them with that strange laughter of his, or with a flow of gibberish that was like nothing human. Bentley shivered. Barter, by his laughter, was identifying himself to the great anthropoids. But with his gibberish was he actually conversing with them? "This experiment of yours," said Bentley when the period of silence became unbearable, "—won't you tell us about it?" The old man cackled. "You'll know all about it—soon! You'll know everything, but the secret will still rest with Caleb Barter. Do not be too curious, my friends." "We are anxious to reach civilization, Professor," said Bentley, deciding to be placative with the old man. "Perhaps you can arrange for guides for us?" Barter laughed. "I could not permit you to leave me for some time," he said. "I want you to witness my experiment. The world would never believe me without the evidence of reliable witnesses." Barter laughed again. They entered a clean clearing which was a riot of flowers. At the further edge was a log cabin of huge proportions. The whole thing had a decidedly homely appearance, but it was a welcome sight to the castaways. There were cages in which strange birds chattered shrilly in their own language at sight of the three. A pair of tame monkeys chased each other on the roof of the house, whose corners were almost hidden by climbing vines whose growth one could almost see. Barter led the way at a swift walk across the clearing and into the house. Bentley gasped. Ellen Estabrook exclaimed with pleasure. The reception room was as neat as though it received the hourly attentions of a fussy housewife. It was cozily furnished, yet it was evident that the furniture had been made on the spot of rough wood and skins of various animals. Deep skin rugs covered the floor and walls. There were three doors giving off of the reception room, all three of which were closed. "You are not married?" he asked the two. "No!" snapped Bentley. "That center door leads to your room, Bentley. The one next to it is for the young lady. The other door? Ah, the other door my friends! That door you must never open. But to make sure that curiosity does not overcome caution, let me show you!" They followed him to the door. He swung it open. Both visitors started back and a gasp of terror burst from the lips of Ellen Estabrook. Beads of perspiration burst forth on Bentley. They saw a huge room. In one corner was a bed. The other held a great cage—and in the cage was an anthropoid ape larger even than the great brute they had met on the trail! Barter laughed. He stepped into the room, uncoiled his whip and hurled the lash at the cage. A great bellowing roar fairly shook the house, while the brute tore at the bars which held him prisoner until the whole massive cage seemed to dance. Barter laughed and continued to goad him. "Barter," yelled Bentley, "stop that! If that beast should ever happen accidentally to get free he'd tear you to pieces!" "I know," said Barter grimly, "and that's part of the experiment! Now we shall eat, and you, young lady, shall tell me what other fool scientists had to say about me after I disappeared—to escape their parrot-like repeating of my discoveries!" Bentley started to offer protest as Barter began preparation for the meal, which obviously was to be taken in the room which held the cage of the giant anthropoid, but Ellen put her fingers to her lips and shook her head. Her eyes were dancing with excitement. About HackerNoon Book Series: We bring you the most important technical, scientific, and insightful public domain books. This book is part of the public domain. Various. 2010. Astounding Stories of Super-Science, June 1931. Urbana, Illinois: Project Gutenberg. Retrieved May 2022 from https://www.gutenberg.org/files/31893/31893-h/31893-h.htm#Manape_the_Mighty . This eBook is for the use of anyone anywhere at no cost and with almost no restrictions whatsoever. You may copy it, give it away or re-use it under the terms of the Project Gutenberg License included with this eBook or online at www.gutenberg.org , located at https://www.gutenberg.org/policy/license.html

Astounding Stories of Super-Science June 1931: Manape the Mighty - Chapter II

Historias asombrosas de superciencia Junio de 1931: Manape the Mighty - Capítulo II

If you have been programming for any length of time, you may well have come across higher-order functions but (like me) may not have fully appreciated just how powerful they can be. If you've not heard of them before, never fear. I have an explanation below. What are higher-order functions? Simply put, a higher-order function is a function whose input or output is also a function. In the following example, the Map function takes a list of a particular data type and a function. It returns a new list with the function applied to each of the elements in the list (basically equivalent to the LINQs Select method). // definition
List<TOut> Map<TIn, TOut>(List<TIn> list, Func<TIn, TOut> mapper)
{
    var newList = new List<TOut>();
    foreach (var item in list)
    {
        var newItem = mapper(item);
        newList.Add(newItem);
    }

    return newList;
}

// usage
var myList = new List<int> { 1, 2, 3, 4, 5 };

int multiplyBy2 (int num) => num * 2;
var multipliedList = Map(myList, multiplyBy2);
// output { 2, 4, 6, 8, 10 };

bool isEven (int num) => num % 2 == 0;
var isEvenList = Map(myList, isEven);
// output { false, true, false, true, false }; Here is an example of a higher-order function that returns a function. First, you call the Add function with a given integer, which returns a function that adds that first integer to any given other integer. Func<int, int> Add(int a) => (int b) => a + b;
		
var add9 = Add(9);
		
var sum1 = add9(1);
// output 10

var sum2 = add9(2);
// output 11 Hopefully, by now, you can see why higher-order functions are so useful; they allow complex code to be reused in a highly flexible way by letting the client define their own input/output functions. For example, without using higher-order functions, one would have to define a new Map function for every type of mapping they needed. Practical Example - Repository Pattern The repository pattern is a very common design pattern used as a data access abstraction. It allows you to perform your typical CRUD operations without the client having to interact directly with the data provider. A typical repository interface may look something like this: public interface IProductRepository
{
    int Create(Product product);
    bool Update(Product product);
    bool Delete(int id);
    Product GetById(int id);
    IEnumerable<Product> GetAll();
    IEnumerable<Product> GetByCategoryId(int categoryId);
    IEnumerable<Product> GetActive();
    // etc...
} As you can see in this typical example, there are numerous definitions that all return . Every time you need another specific type of product filter, that requires adding to the interface and writing an entirely new implementation. That's not great for maintainability... IEnumerable<Product> Instead, using higher-order functions, we can define a single method that gets that takes a filter function as an input. That way, the client is free to define their own filters, and the ProductRepository doesn't need to keep being updated with new implementations. IEnumerable<Product> interface IProductRepository
{
    // create, update, delete omitted
    
    IEnumerable<Product> Get(Func<Product, bool> filter = null);
}

public class ProductRepository : IProductRepository
{
    private readonly List<Product> _products = new List<Product>(); // data source

    public IEnumerable<Product> Get(Func<Product, bool> filter = null)
    {
        // typically you might use the LINQ Where method here
        // but using the foreach to be clear what is happening

        if (filter is null) return _products;     

        var filteredList = new List<Product>();
        foreach(var product in _products)
        {
            if(filter(product))
            {
                filteredList.Add(product);
            }
        }

        return filteredList;
    }
} // client code
var allProducts = _productRepository.Get();
var productsByCategoryId = _productRepository.Get(p => p.CategoryId == 1);
var activeProducts = _productRepository.Get(p => p.Active); Conclusion In this article, I have introduced the concepts of higher-order functions and demonstrated how they are extremely useful in creating reusable and flexible code that is easy to maintain and understand. I have also given a practical use case that you may find in a .NET enterprise application - making the repository pattern more reusable. I post mostly about full-stack .NET and Vue web development. To make sure that you don't miss out on any posts, please follow this blog and . If you found this post helpful, please like it and share it. You can also find me on . subscribe to my newsletter Twitter Also published on . https://samwalpole.com/a-practical-guide-to-higher-order-functions-in-c

Higher Order Functions in C#: A Practical Example

Nobody likes repetitive tasks. So why should you run all your tests manually with every new code or—even worse—check that the new code didn’t break your build process? Yeah, I know you want to spend your precious time on shiny features without having to waste hours tweaking your build pipeline. Or maybe you have excuses like “I would have to pay for the automation” or “It’s time-consuming to prepare pipelines, and I don’t have time for it.” It’s not necessary to spend hours setting up your automation pipelines. Check out this guide and spin up a GitHub Action for your favorite stack fast—like Stack Overflow copy & paste fast. TL;DR If you are familiar with GitHub Actions, you can skip the theory and jump to the specific stack in the Examples section below. Continuous Integration and Continuous Delivery Let’s start with the basics. The terms might sound very technical at first. However, the basic concept is quite simple. is the automation of building and testing. This means that typically, with some code changes, the machine checks whether it’s possible to build the project and whether your tests are passing. is a little bit broader. To sum it up, this automation process will deploy or publish your code to various environments. This might be a little bit abstract and connected with the nature of your project, but you can visualize it as publishing to package registries like NPM or Nuget—or deploying your site to a staging or production environment. Continuous integration Continuous delivery GitHub Actions GitHub Actions are the feature of GitHub that consists of the API and an environment for running your tasks. You just need to create a YAML file at a specific location in the repository. The configuration .yml file contains all the specific information about the environment, such as , , or . Additionally, you can choose the environment where you want to run your tasks—it might be Linux (Ubuntu), Windows (Windows Server), or even macOS (Big Sur or Catalina). trigger events jobs strategies The anatomy of the Action Each action is represented by a file located directly in the repository at the . To be able to run it, you need to allow the Actions feature in the repository’s Settings. .yml .github/workflows location Note: If you are not familiar with the YAML format, for the purposes of the GitHub Actions, you just need to know that key-value pairs are represented by key: value . The quotes for string values are optional. Nesting of objects is done by indentation (typically two spaces), and items of the array are denoted by a dash. key: value nested_property: Nested value my_array: - First Item - Second Item GitHub Actions basic syntax keys - The name of the workflow. name - Is required, specifies events when you want to run your action. on - A job is a unit of work; jobs run in parallel by default. Each job runs in a runner environment specified by runs-on. jobs - Is required, specifies the type of the machine to run the job. jobs.<job_id>.runs-on - A step is an individual task that can run commands in a job. A step can be either an or a shell command. Each step in a job executes on the same runner, allowing the actions in that job to share data with each other ( ). jobs.<job_id>.steps action definition by GitHub - Selects an action to run as part of a step in your job. This is beneficial for reusing existing actions. You can check existing actions in the official or on the . jobs.<job_id>.steps[*].uses actions repository marketplace - Provides a shell where you can run your commands. jobs.<job_id>.runs-on Hello World Action Let’s write the action that runs every day. This action will run on Ubuntu, using code from our repository, and will run our main.py script on the environment with Python 3.8. The explanation of each line is described in the respective comment directly in the code. the Python script Create in the root of your repository with content . main.py print("Hello, World!") In the create the file with the following content. .github/workflows minimal-action.yml name: Hello World From Python #  Represents the name of the whole action. on: # Specifies the section where we describe our build triggers. schedule: # Specifies the section where we describe the schedule of running the action. - cron: '* 1 * * *' # The CRON expression describing when to run the action. workflow_dispatch: #  Adds the ability to run the action manually by button on the Actions tab. jobs: # Specifies the section where we describe our jobs. hello_world_job: # Specific job section. name: A greeting job # The name of the job. runs-on: ubuntu-latest # Describes the environment. steps: # Specifies the section where we describe the job's steps. - name: Checkout # The name of the step. uses: actions/checkout@v2 # Using already existing action actions/checkout@v2. This action provides us with access to the code of the repository. - name: Set up Python 3.8 # The name of the step. uses: actions/setup-python@v1 # Using already existing action actions/setup-python@v1. This action sets up a Python environment for us. with: # Configuration of the python action. python-version: 3.8 # Specific python version. - name: Run the script # The name of the step. run: python main.py # Command for running our main.py. Real-world examples It’s not possible to cover all capabilities and combinations here. Nevertheless, in this section, you can find some real-world examples—you can choose them for scaffolding your Action quickly for your specific stack and use case. They showcase configuration for various languages, platforms, and publishing to external package repositories. However, before we start, we’ll need some more commands for these real-world examples. - Runs the action when a specific release event occurs. on.release.types - Runs an action when push or pull request event occurs on a specific branch. on.<push|pull_request>.<branches|tags> - Allows to set different job configurations. jobs.<job_id>.strategy.matrix - Context for specified environment variables. env - Specifies the location of stored . It’s a good practice to store secrets and keys to storage of the repository. env.NODE_AUTH_TOKEN NPM_TOKEN Encrypted Secrets - The job will run if the condition is met. jobs.<job_id>.if Build Node.js app and publish to the NPM registry The Action that builds the Node.js project written in TypeScript and publishes the package to the NPM registry when the release is created. The publishing of the NPM package is performed by the command. npm publish on: release: types: [published] name: publish-to-npm jobs: publish: runs-on: ubuntu-latest strategy: matrix: node-version: [14.x] steps: - uses: actions/checkout@v2 - name: Use Node.js ${{ matrix.node-version }} uses: actions/setup-node@v1 with: node-version: ${{ matrix.node-version }} registry-url: 'https://registry.npmjs.org' - run: npm install - run: npm run build - run: npm publish env: NODE_AUTH_TOKEN: ${{ secrets.NPM_API_KEY }} Build Ruby website and publish it to GitHub Pages The action that runs with push or pulls request to master. The action builds the Jekyll project and publishes it to a specific folder. After running this action, the site is accessible on . GitHub Pages name: Ruby on: push: branches: [master] pull_request: branches: [master] jobs: build: runs-on: ubuntu-latest strategy: matrix: ruby-version: ["2.6"] env: PROJECT_ID: ${{ secrets.PROJECT_ID }} steps: - uses: actions/checkout@v2 - name: Set up Ruby uses: ruby/setup-ruby@v1 with: ruby-version: ${{ matrix.ruby-version }} bundler-cache: true # runs 'bundle install' and caches installed gems automatically - name: Update gems run: gem update --system - name: Install required packages run: gem install jekyll bundler kontent-jekyll - name: Build the output run: bundle exec jekyll build env: JEKYLL_ENV: production - name: Deploy 🚀 if: github.ref == 'refs/heads/master' # Checks if the current branch is master. uses: JamesIves/github-pages-deploy-action@3.6.2 with: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} BRANCH: gh-pages FOLDER: _site CLEAN: true # Automatically remove deleted files from the deploy branch Build the Ruby project and publish it to RubyGems The Ruby project is built and published to . This example uses action for publishing. RubyGems dawidd6/action-publish-gem name: publish-gem on: release: types: [published] jobs: publish: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Set up Ruby uses: ruby/setup-ruby@v1 with: ruby-version: 2.6 - name: Install dependencies run: bundle install - name: Run tests run: bundle exec rake - name: Publish gem uses: dawidd6/action-publish-gem@v1 with: api_key: ${{secrets.RUBYGEMS_API_KEY}} Node.js app with tests The tests are performed by executing the command. npm run test:all name: Test on: [pull_request] jobs: build: runs-on: ubuntu-latest strategy: matrix: node-version: [14] steps: - uses: actions/checkout@v2 - name: Use Node.js ${{ matrix.node-version }} uses: actions/setup-node@v1 with: node-version: ${{ matrix.node-version }} - run: npm i - run: npm run test:all Node.js app with UI tests using a browser Sometimes the test environment requires a browser, and default virtual environments come with a lot of . This action runs tests directly in the browser using the command. preinstalled browsers npm run test:all name: Test on: [pull_request] jobs: build: runs-on: windows-latest strategy: matrix: node-version: [14.x] steps: - uses: actions/checkout@v2 - name: Use Node.js ${{ matrix.node-version }} uses: actions/setup-node@v1 with: node-version: ${{ matrix.node-version }} - run: npm i - run: npm run test:all PHP project using Composer and Codecov This action sets up the PHP environment on the Ubuntu machine using . Moreover, it validates and caches packages. In the end, it runs a code coverage tool by . shivammathur/setup-php@v2 Composer Codecov name: Build & Test & Report on: push: branches: [ master ] pull_request: branches: [ master ] jobs: build: runs-on: ubuntu-latest strategy: matrix: php-versions: ['7.0', '7.1' , '7.2' , '7.3' ] phpunit-versions: ['latest'] steps: - uses: actions/checkout@v2 - name: Setup PHP uses: shivammathur/setup-php@v2 with: php-version: ${{ matrix.php-versions }} extensions: mbstring, intl ini-values: post_max_size=256M, max_execution_time=180 coverage: xdebug tools: php-cs-fixer, phpunit:${{ matrix.phpunit-versions }} - name: Validate composer.json and composer.lock run: composer validate --strict - name: Cache Composer packages id: composer-cache uses: actions/cache@v2 with: path: vendor key: ${{ runner.os }}-php-${{ hashFiles('**/composer.lock') }} restore-keys: |
          $ -php- {{ runner.os }} - name: Install dependencies run: composer install --prefer-dist --no-progress --no-suggest - name: Coverage run: vendor/bin/phpunit --coverage-clover coverage.xml - name: Codecov uses: codecov/codecov-action@v1 Build, test, and publish to Nuget .NET Core package This example covers the release process of the .NET Core SDK package. The action restores packages, builds the solution, runs tests, and publishes artifacts to . Nuget name: Publish to NuGet on: release: types: [published] jobs: build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Setup .NET uses: actions/setup-dotnet@v1 with: dotnet-version: 5.0 .x - name: Extract version from tag id: get_version uses: battila7/get-version-action@v2 - name: Restore dependencies run: dotnet restore - name: Build run: dotnet build --no-restore --configuration Release /p:ContinuousIntegrationBuild=true /p:Version="${{ steps.get_version.outputs.version-without-v }}" - name: Test run: dotnet test --no-build --verbosity normal --configuration Release /p:CollectCoverage=true /p:CoverletOutputFormat=opencover - name: Codecov uses: codecov/codecov-action@v1 - name: Pack run: dotnet pack --no-build --include-symbols --verbosity normal --configuration Release --output ./artifacts /p:PackageVersion="${{ steps.get_version.outputs.version-without-v }}" - name: Upload artifacts uses: actions/upload-artifact@v2 with: name: "NuGet packages" path: ./artifacts - name: Publish artifacts to NuGet.org run: dotnet nuget push './artifacts/*.nupkg' -s https://api.nuget.org/v3/index.json -k ${NUGET_API_KEY} --skip-duplicate env: NUGET_API_KEY: ${{ secrets.NUGET_API_KEY }} - name: Upload artifacts to the GitHub release uses: Roang-zero1/github-upload-release-artifacts-action@v2.1.0 with: args: ./artifacts env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} Build, test, and publish Java project to Nexus registry In this Action, the package is built and published using . The package is deployed to the repository. Gradle Nexus name: Publish package to the Maven Central Repository on: release: types: [created] jobs: publish: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Set up Java uses: actions/setup-java@v1 with: java-version: 1.8 - name: Grant execute permission for gradlew run: chmod +x gradlew - name: Version release run: echo Releasing verion ${{ github.event.release.tag_name }} - name: Publish package run: ./gradlew publish env: RELEASE_TAG: ${{ github.event.release.tag_name }} NEXUS_USERNAME: ${{ secrets.NEXUS_USERNAME }} NEXUS_PASSWORD: ${{ secrets.NEXUS_PASSWORD }} SIGNING_KEY_ID: ${{ secrets.SIGNING_KEY_ID }} SIGNING_KEY: ${{ secrets.SIGNING_KEY }} SIGNING_PASSWORD: ${{ secrets.SIGNING_PASSWORD }} Build test and publish to Cocoapods project written in Swift At first, the dependencies are restored. Afterward, the project is built, and the Action runs tests. In the end, the package is pushed to the Cocoapods repository using the command. Cocoapods pod trunk push on: release: types: [published] name: publish-to-cocoapods jobs: publish-to-cocoapods: name: publish-to-cocoapods runs-on: macOS-latest strategy: matrix: destination: ['platform=iOS Simulator,OS=12.2,name=iPhone 11 ']
    steps:
      - name: Checkout
        uses: actions/checkout@master
      - name: Build and test
        run: |
          gem install cocoapods
          pod repo update
          pod install --project-directory=Example
          set -o pipefail && xcodebuild test -enableCodeCoverage YES -workspace Example/KenticoKontentDelivery.xcworkspace -scheme KenticoKontentDelivery-Example -sdk iphonesimulator -destination ' name=iPhone 11 ' ONLY_ACTIVE_ARCH=NO | xcpretty
      - name: Publish Cocoapod
        run: pod trunk push
        env:
          COCOAPODS_TRUNK_TOKEN: $ {{ secrets.COCOAPODS_TRUNK_TOKEN }} Bonus: GitHub Actions not only for CI/CD automation Not only can GitHub Actions be used for automating your build, running tests, and release pipelines but you can also leverage them for scheduling automatic tasks, such as web scraping or automatic update routines. This last bonus action runs the Python script at a specific time. The Python script does some automation—in this case, it scrapes the HTML page and makes data readable for machine processing. The output of the script is then committed and pushed to the specified GIT repository. name: Python application on: push: branches: [ master ] pull_request: branches: [ master ] schedule: - cron: '0 0 * * *' jobs: build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Set up Python 3.8 uses: actions/setup-python@v1 with: python-version: 3.8 - name: Install dependencies run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt - name: Lint with flake8 run: |
        pip install flake8
        # stop the build if there are Python syntax errors or undefined names
        flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
        # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics - name: Run script run: |
        python stocks.py - name: Deploy page run: |
        git config --local user.email "action@github.com"
        git config --local user.name "GitHub Action"
        git add docs/index.html -f
        git commit -m "Update docs/index.html" -a
        git push "https://makma:$ @github.com/makma/stocks-movement.git" HEAD:master --follow-tags {{ secrets.GITHUB_PERSONAL_TOKEN }} Debrief I believe GitHub Actions can be utilized for many different scenarios. You can find the majority of the example actions above in real-world use—they were based on and taken over from open-source . Feel free to take a look, get inspired, or maybe improve them ;). Didn’t you find your use case in the examples above, or did I not include your favorite GitHub Actions feature? Let me know on or . I’ll be happy to discuss your use case and update the article. Kentico Kontent’s GitHub Twitter Discord

With GitHub Actions, you don’t have to do boring tasks manually ever again

When dealing with VBA for Excel, you'd be forgiven for thinking that your code would work with Excel only. However, the fact that VBA (Visual Basic for Applications) is common to all the applications within Office Suite opens up a host of possibilities. For instance, you can capture data in Excel via a user form and then automatically export it to a Word document. The beauty of this is that everything executes in the background. In other words, you don't need to manually copy data from Excel, search for the correct Word document to paste this information, save the file, and then close Word again. Our book addresses these topics. VBA Automation for Excel 2019 Cookbook In this article, we’ll look at recipes for: Creating a new instance of Word Writing and formatting text Copying data into Word Using templates and bookmarks By the end, you’ll be able to create Word documents from within Excel. Technical requirements These recipes were written and designed to be used with MS Office 2019 and MS Office 365, installed on either Windows 8, 8.1, or 10. If your hardware and software meet these requirements, you are good to go. Demonstration files can be downloaded from . https://github.com/PacktPublishing/VBA-Automation-for-Excel-2019-Cookbook Please visit the following link to check the Code in Action videos: . https://bit.ly/3jQRvVk Creating a new instance of Word The first step in the process of creating a Word document from within Excel requires some changes to the available references. To be specific, we have to set a reference to Word's object library in the VBA Editor. Without this step, Excel cannot communicate with Word at all, let alone create documents and paragraphs. In this recipe, we will be creating a new instance of Word from within Excel. Getting ready Open Excel, and activate a new workbook. Save the file as a macro-enabled file (*.xlsm) on your desktop and call it Word_Interaction.xlsm. Sheet1 should be active. Press Alt + F11 to switch to the VBA Editor, and then insert a new module. It goes without saying that MS Word must also be installed on your computer in order for the instructions in this recipe to work effectively. How to do it… Here’s how to link Word to Excel: 1. In the VBA Editor, click on Tools | References. The References – VBAProject dialog box will open: Figure 1 – The References - VBAProject dialog box 2. Scroll down the list of available references until you find Microsoft Word 16.0 Object Library. Earlier versions of Word will have a different number, but will still refer to the Word object library: Figure 2 – The Microsoft Word 16.0 Object Library selected 3. Once selected, click on OK to save the selection and close the dialog box. Note
: The reference to the Word object library is only valid for the Excel workbook you're currently working in. Every new workbook will have to be referenced to Word in exactly the same way. 4. Create a Sub procedure to initiate Word from within Excel. There are several ways of doing this, but for this recipe, we will be using this specific technique: Sub CreateWordDoc()
Dim wdApp As Word.Application wdApp = New Word.Application
wdApp.Visible = True
wdApp.Activate
End Sub Set 5. Press F5 to run the procedure, or to test it, if you will. A new instance of Word will appear on your screen. Close the Word application once you know that the Sub procedure is working. 6. Opening Word without opening a new document is not very useful. Add the next lines of code to the Sub procedure to open a new document: CreateWordDoc() wdApp Word.Application wdApp = Word.Application wdApp
.Visible = .Activate
.Documents.Add Sub Dim As Set New With True End With End Sub Note: Because we need to use the Word.Application keyword every time we refer to MS Word, the loop structure makes it easier to refer to Word.Application via the wdApp variable. If you now run the procedure, Word will open again, this time displaying a new document, . Document1 Close Word, but don't save the document. Return to the VBA Editor in Excel. These steps will enable you to create a new instance of Word from within Excel, using VBA for Excel. How it works… Enabling the Microsoft Word object library for this Excel workbook made it possible to use Word keywords and methods within Excel. These keywords can open an instance of Word, as well as a new Word document, all from within Excel. Writing and formatting text It's all very well to know how to open Word with a new document available. However, we need more than this. A heading for the new document would be a good start, but that is still not enough. Formatting the heading is also necessary, and will round it off professionally. In this recipe, we will be writing and formatting text. Getting ready Make sure Word_Interaction.xlsm is still open, and that the VBA Editor is active. How to do it… These are the steps to enter and format text in Word: 1. To add text to a Word document via Excel, add the following line of code: CreateWordDoc() wdApp Word.Application wdApp = Word.Application wdApp
.Visible = .Activate
.Documents.Add
.Selection.TypeText Sub Dim As Set New With True "Employee Information" End With End Sub 2. Press F5. Running the Sub procedure will now result in a new instance of Word, with a new document open, and the line of text in the Sub procedure at the top of the page. Close Word without saving, since there is more code to add to our procedure in Excel: Figure 3 – New instance of Word, with document and text 3. It is quite clear that we need to do some formatting here. By starting a nested loop structure, this will save us repeating the keywords. Furthermore, if you haven't done it so far, you can use IntelliSense to assist you with all the Word keywords. Add the following lines of code to the VBA Editor: CreateWordDoc() wdApp Word.Application wdApp = Word.Application wdApp
.Visible = .Activate
.Documents.Add .Selection
.ParagraphFormat.Alignment = _
wdAlignParagraphCenter
.BoldRun .Font.Size = .TypeText .BoldRun .TypeParagraph .Font.Size = .ParagraphFormat.Alignment = _
wdAlignParagraphLeft
.TypeParagraph Sub Dim As Set New With True With 'Switch Bold on 16 "Employee Information" 'Switch Bold off 'Enter a new line 11 End With End With End Sub 4. When you run the Sub procedure now, there will be a marked improvement in appearance: Figure 4 – Formatting done via VBA in Excel Using these principles, users will be able to format a Word document with VBA coding in Excel. Copying data into Word We could have opened Word manually and achieved what we've just done, but the whole purpose of the exercise is to do it from Excel, so that data in a spreadsheet can be written to the Word document automatically. What we need to do now is select data, copy it, and then paste that as part of the opening and formatting process. In this recipe, we will be copying data into Word. Getting ready Make sure that Word_Interaction.xlsm is still open. Activate Sheet1, and enter the following data: Figure 5 – Working data How to do it… Follow these steps to copy text from Excel to Word: 1. Create code to automatically select whatever range is on a sheet: Sub CreateWordDoc()
Dim wdApp As Word.Application wdApp = New Word.Application
With wdApp
.Visible = True
.Activate
.Documents.Add
With .Selection
.ParagraphFormat.Alignment = _
wdAlignParagraphCenter
.BoldRun Switch Bold off
.TypeParagraph Set 'Switch Bold on
.Font.Size = 16
.TypeText "Employee Information"
.BoldRun ' 'Enter a new line
.Font.Size = 11
.ParagraphFormat.Alignment = _
wdAlignParagraphLeft
.TypeParagraph
End With
End With Range( , Range( ).End(xlDown) _
.End(xlToRight)).Copy
wdApp.Selection.Paste
End Sub "A1" "A2" 2. Run the Sub procedure to check your coding. We know that the first part will work, but in this case, we need to see whether the data on our spreadsheet was copied into Word: Figure 6 – Excel data copied and pasted into Word 3. Saving the Word document is what we need to do next. When you add these lines of code, pay attention to the changes in the With statement: Sub CreateWordDoc()
Dim wdApp As Word.Application wdApp = New Word.Application
With wdApp
.Visible = True
.Activate
.Documents.Add

With .Selection
.ParagraphFormat.Alignment = _
wdAlignParagraphCenter
.BoldRun Switch Bold off
.TypeParagraph Set 'Switch Bold on
.Font.Size = 16
.TypeText "Employee Information"
.BoldRun ' 'Enter a new line
.Font.Size = 11
.ParagraphFormat.Alignment = _
wdAlignParagraphLeft
.TypeParagraph
End With

Range("A1", Range("A2").End(xlDown) _
.End(xlToRight)).Copy
.Selection.Paste
.ActiveDocument.SaveAs2 Environ("UserProfile") _
& "\Desktop\EmployeeReport.docx"
End With
End Sub 4. The last thing we need to do is close down the document, and finally Word itself. Just add the following two lines in a new line after the filename: .ActiveDocument.Close
.Quit 5. When you run the procedure now, you will see Word open briefly, and immediately close again. If you want to eliminate that, simply comment the following two lines out: ' = True
' .Visible .Activate 6. We're still not done, because every time we run the procedure, the file is replaced without giving us the option of saving it under a new name. We need to add code to create a unique filename every time we run the procedure. By declaring a new variable, SaveAsName, and then assigning a formatted version of the Now function, we can create a unique name for the file every time it is saved. Add these two lines after .Selection.Paste: SaveAsName = Environ( ) _
& _
& Format(Now, ) & .ActiveDocument.SaveAs2 SaveAsName "UserProfile" "\Desktop\EmployeeReport " "yyyy-mm-dd hh-mm-ss" ".docx" 7. Every time you run the procedure now, a new file with a unique name will be saved. Following these instructions will enable you to automatically copy data from Excel into Word. How it works… Here’s an explanation of what we did. Selecting data in Excel is not a new concept, and neither is copying. Saving it in a Word document with Excel VBA requires making use of the Environ function, as well as formatting of the filename. This will ensure that a new file is created every time the Excel VBA procedure is executed. Using templates and bookmarks To copy an entire Excel spreadsheet and paste it into Word doesn't make sense. You could rather have done everything in Word from the beginning, saving you the whole effort of copying from Excel and pasting in Word. The point is, if you have an existing Word document or even a Word template, and you regularly need to export selected information from a spreadsheet in Excel to this template, this is the way to do it. The word automation acquires new meaning if you can link Excel with Word in this manner. In this recipe, we will be pasting Excel data into a Word document at a specific bookmark. Getting ready Make sure that Word_Interaction.xlsm is still open, and that the VBA Editor is active. How to do it… We need to do the following: 1. Open the Word document that was saved to the desktop. Delete the inserted table (select only the entire table – no lines before or after, click the contextual tab, and then ) Layout Rows & Columns | Delete | Delete Table 2. Enter the short sentence Latest information on employees in the open space. 3. Insert a bookmark in the first open line after this sentence. Click on . The dialog box will appear. Enter a name in the textbox, and then click on to close the dialog box: Insert | Bookmark Bookmark Bookmark name Add Figure 7 – Bookmark name 4. Click on , and save the file as a Word template. The file extension is .dotx. Call the file EmployeeReportTemplate. File | Save As 5. Depending on the operating system and the version of MS Office on your PC, the file will be saved in a specific folder, dedicated to template files: Figure 8 – Folder for template files 6. Close the file and return to the VBA Editor in Excel. 7. Add the following line of text in the code window to open a specific file, and not just a blank document: Sub CreateWordDoc()
Dim wdApp As Word.Application wdApp = New Word.Application
With wdApp
.Visible = True
.Activate
.Documents.Add Set "C:\Users\User\Documents\Custom _
Office Templates\EmployeeReportTemplate.dotx" 8. Because we're making use of a template, we do not need any of the formatting we did for the previous document. Delete the following lines of code: With = _
wdAlignParagraphCenter 'Switch Bold on = 16 'Switch Bold off 'Enter a new line = 11 = _
wdAlignParagraphLeft End With .Selection .ParagraphFormat.Alignment .BoldRun .Font.Size .TypeText "Employee Information" .BoldRun .TypeParagraph .Font.Size .ParagraphFormat.Alignment .TypeParagraph 9. Use the GoTo method to instruct Word exactly where the copied data from Excel must be inserted. That's why we created a bookmark in the Word template. The final coding for the entire procedure should look like this: Sub CreateWordDoc()
Dim wdApp Word.Application
Dim SaveAsName String wdApp = Word.Application wdApp .Activate

.Documents. "C:\Users\User\Documents\Custom _
Office Templates\EmployeeReportTemplate.dotx"

Range("A1", Range("A2"). (xlDown) _
. (xlToRight)). .Selection.Goto wdGoToBookmark, , , "ExcelTable"
.Selection.Paste

SaveAsName = Environ("UserProfile") _
& "\Desktop\EmployeeReport " _
& Format(Now, "yyyy-mm-dd hh-mm-ss") & ".docx"

.ActiveDocument.SaveAs2 SaveAsName
.ActiveDocument. .Quit Sub As As Set New With '.Visible = True
' Add End End Copy Close End With End These instructions will enable you to create a template in Word, and then automatically place content from Excel into the Word document at specific bookmarks. Inserting Excel data into a Word template can be done with Excel VBA. Inserting a bookmark in the Word template enables Excel to send data to a specific insertion point for the data to be pasted. See also Visit for more information on the GoTo method. https://docs.microsoft.com/en-us/office/vba/api/word.selection.goto To read a more in-depth guide check out our book , authored by Mike Van Niekerk. VBA Automation for Excel Cookbook You can get 25% off at . Use discount code (Promotion running from 10th February through 15th March). http://packt.live/3u1fPtG 25VBA

How to Create Word Documents Within Excel VBA

Cómo crear documentos de Word dentro de Excel VBA

The SAS (Statistical Analysis System) Response To SQL Challenges in a Data Warehouse Environment

If you’ve been following developments in deep learning and natural language processing (NLP) over the past few years then you’ve probably heard of something called ; and if you haven’t, just know that techniques owing something to BERT will likely play an increasing part in all our digital lives. BERT is a state-of-the-art embedding model published by Google, and it represents a breakthrough in the field of NLP by providing excellent results on many NLP tasks, including question answering, text generation, sentence classification, and more. BERT Here we are going to look at what BERT is and see what is distinctive about it, by looking in a relatively high-level way (eschewing the underlying linear algebra) at the internal workings of the BERT model. By the end you should have if not a detailed understanding then at least a strong sense of what underpins this modern approach to NLP and other methods like it. T Basic Ideas Behind BER BERT stands for Bidirectional Encoder Representations from Transformers. As we’ve said, it’s a state-of-the-art embedding model from researchers at Google. By calling it an embedding model we mean that, fed with natural language input, it generates vector-based representations – embeddings –of those inputs. One of the major reasons for BERT’s success is that it is a context-based embedding model, unlike other popular embedding models, such as word2vec, which are context-free. First, let's look at the difference between context-based and context-free embedding models. Consider the following two sentences: Sentence A: He got bitten by a python. Sentence B: Python is my favorite programming language. We understand, as soon as we read them, that the meaning of the word 'python' is different in the two sentences. In sentence A, the word 'python' refers to the snake, while in sentence B it refers to the programming language. Now, if we derive embeddings for the word 'python' in the preceding two sentences using an embedding model such as word2vec, the embedding of the word 'python' would be the same in both sentences, rendering the meaning of the word 'python' the same in both sentences. This is because word2vec, being a context-free model, will ignore the context and always give the same embedding for the word 'Python' irrespective of context. BERT, on the other hand, being a context-based model, will understand the context and then generate the embedding for the word based on that context. So, for the preceding two sentences, it will give different embeddings for the word 'python', according to the context. Take sentence A: He got bitten by a python. First, BERT relates each word in the sentence to all the other words in the sentence to understand the contextual meaning of every word. So, to understand the contextual meaning of the word 'python', BERT takes the word 'python' and relates it to all the words in the sentence. By doing this, BERT can understand that the word 'python' in sentence A denotes the snake through its relationship to the word ‘bitten’. Now, let's take sentence B: Python is my favorite programming language. Similarly, here BERT relates each word in the sentence to all the words in the sentence to understand the contextual meaning of every word. So, BERT takes the word 'python' and relates it to all the words in the sentence to understand the meaning of the word 'python'. By doing this, BERT understands that the word 'python' in sentence B is related to a programming language through its relationship to the word ‘programming’. Thus, unlike context-free models such as word2vec, which generate static embeddings irrespective of the context, BERT generates dynamic embeddings based on the context. How does BERT do that? BERT’s workings Bidirectional Encoder Representations from Transformers (BERT), as the name suggests, is based on the transformer model. Let’s investigate what that means. The transformer model Recurrent neural networks (RNNs) and Long Short-Term Memory (LSTM) networks are widely used in sequential tasks such as next word prediction, machine translation, text generation, and more. However, one of the major challenges with the recurrent model is capturing long-term dependency. To overcome this limitation of RNNs, a new architecture, called the transformer model, was introduced in the paper Attention Is All You Need (see Further reading). The transformer is currently the state-of-the-art model for several NLP tasks, and has paved the way for revolutionary new architectures such as BERT, GPT-3, T5, and more. The transformer model is based entirely on something called the attention mechanism. It gets rid of recurrence completely. The transformer uses a special type of attention mechanism called self-attention. Let’s consider how the transformer works with a language translation task. The transformer consists of an encoder-decoder architecture. We feed the input sentence (source sentence) to the encoder. The encoder learns the representation of the input sentence and sends the representation to the decoder. The decoder receives the representation learned by the encoder as input and generates the output sentence (target sentence). Suppose we need to convert a sentence from English to French. As shown in the following figure, we feed the English sentence as input to the encoder. The encoder learns the representation of the given English sentence and feeds the representation to the decoder. The decoder takes the encoder's representation as input and generates the French sentence as output: Figure 1 – Encoder and decoder of the transformer Encoder The transformer consists of a stack of encoders. The output of one encoder is sent as input to the encoder above it. Each encoder sends its output to the encoder above it. The final encoder returns the representation of the given source sentence as output. We feed the source sentence as input to the encoder and obtain the representation of the source sentence as output: Figure 2 – A stack of N encoders Note that in the transformer paper Attention Is All You Need, the authors used N = 6, meaning that they stacked up six encoders one above the another. However, we can use different values of N. For simplicity and better understanding, let's keep N = 2: Figure 3 – A stack of encoders Now how does the encoder work? How is it generating the representation for the given source sentence (input sentence)? The following figure shows the components of the encoder: Figure 4 – Encoder with its components All the encoder blocks are identical. We see that each encoder block consists of two sublayers: Multi-head attention Feedforward network Actually there’s rather more to it than that. The multi-head attention block can be thought of as a sophisticated method for computing, from input word embeddings, the self-attention values of words, which is a way of allowing the transformer to understand how one word is related to all the other words in the expression. The following figure shows encoder internal structure in more detail: Figure 5 – A stack of encoders with encoder 1 expanded As well as using attention matrices to understand how individual words in the input relate to all the other words, you can see that positional encoding plays a part in proceedings. It is therefore worth quickly saying what positional encoding is. Positional encoding Consider the input sentence I am good. In RNNs, we feed the sentence to the network word by word. That is, first the word I is passed as input, next the word am is passed, and so on. We feed the sentence word by word so that our network understands the sentence completely. But with the transformer network, we don't follow the recurrence mechanism. Instead of feeding the sentence word by word, we feed all the words in the sentence parallel to the network. Feeding the words in parallel helps to decrease the training time and also helps in learning the long-term dependency. However, how will the transformer understand the meaning of the sentence if the word order is not retained? To understand the sentence, the word order (position of the words in the sentence) is important, right? Yes, since the position of each word in a sentence contributes to the meaning of the sentence. So, we should give some information about the word order to the transformer so that it can understand the sentence. That’s what positional encoding accomplishes. Now, going back to Figure 5, we see the following: First, we convert our input to an input embedding (embedding matrix), and then add the position encoding to it and feed it as input to the bottom-most encoder (encoder 1). Encoder 1 takes the input and sends it to the multi-head attention sublayer, which returns the attention matrix as output. We take the attention matrix and feed it as input to the next sub-layer, which is the feedforward network. The feedforward network takes the attention matrix as input and returns the encoder representation as output. Next, we take the output obtained from encoder 1 and feed it as input to the encoder above it (encoder 2). Encoder 2 carries the same process and returns the encoder representation of the given input sentence as output. We can stack N encoders one above the other; the output (encoder representation) obtained from the final encoder (topmost encoder) will be the representation of the given input sentence. Contextual word representations After that deep-dive into the Transformer model and encoders let’s get back to BERT. We see that BERT uses the transformer model but includes only the encoder part. In the previous section we saw that we feed a sentence as input to the transformer's encoder and it returns the representation for each word in the sentence as an output. Well, that's exactly what BERT is – Encoder Representation from Transformer. Okay, so what about that term Bidirectional? The encoder of the transformer is bidirectional in nature since it can read a sentence in both directions. Thus, BERT is basically the Bidirectional Encoder Representation obtained from the Transformer. Let's understand this better using the same sentences we saw in the previous section. We’ll go back to our previous sentence A: ‘He got bitten by Python’. Now, we feed this sentence as an input to the transformer's encoder and get the contextual representation (embedding) of each word in the sentence as an output. Once we feed the sentence as an input to the encoder, the encoder understands the context of each word in the sentence using the multi-head attention mechanism (which relates each word in the sentence to all the words in the sentence to learn the relationship and contextual meaning of words) and returns the contextual representation of each word in the sentence as an output. As shown in the following diagram, we feed the sentence as an input to the transformer's encoder and get the representation of each word in the sentence as an output. We can stack up N encoders, as shown in the following diagram. We have only expanded encoder 1 so as to reduce clutter. In the following diagram, RHe denotes the representation of the word 'He', Rgot is the representation of the word 'got', and so on. The representation size of each token will be the size of the encoder layer. Suppose the size of the encoder layer is 768, then the representation size of each token will be 768: Figure 6 – BERT generating the representation of each word in the sentence Similarly, if we feed sentence B, 'Python is my favorite programming language', to the transformer's encoder, we get the contextual representation of each word in the sentence as output, as shown in the following diagram: Figure 7 – BERT generating the representation of each word in the sentence Thus, with the BERT model, for a given sentence, we obtain the contextual representation (embedding) of each word in the sentence as an output. Now that we understand how BERT generates contextual representation, let’s look at the different available configurations of BERT. Configurations of BERT The BERT’s developers have made the model available in two standard configurations: BERT-base BERT-large BERT-base consists of 12 encoder layers, stacked one on top of the other. All the encoders use 12 attention heads. The feedforward network in the encoder consists of 768 hidden units. Thus, the size of the representation obtained from BERT-base will be 768. We use the following notations: The number of encoder layers is denoted by L. The attention head is denoted by A. The hidden unit is denoted by H. Thus, in the BERT-base model, we have L = 12, A = 12, and H =768. The total number of parameters in BERT-base is 110 million. The BERT-base model is shown in the following diagram: Figure 8 – BERT-base BERT-large consists of 24 encoder layers, each stacked one on top of the other. All the encoders use 16 attention heads. The feedforward network in the encoder consists of 1,024 hidden units. Thus, the size of the representation obtained from BERT-large will be 1,024. Hence, in the BERT-large model, we have L = 24, A = 16, and H =1024. The total number of parameters in BERT-large is 340 million. The BERT-large model is shown in the following diagram: Figure 9 – BERT-large Both BERT models have been pre-trained on two large text corpora, the Toronto BookCorpus (800m words) and English Wikipedia (2500m words), using two training tasks: next sentence prediction and masked language modeling (i.e. fill in the missing word in a sentence). Apart from the preceding two standard configurations, we can also build the BERT model with different configurations. We can use smaller configurations of BERT in settings where computational resources are limited. However, the standard BERT configurations, such as BERT-base and BERT-large, give more accurate results and they are the most widely used. Using BERT At this point you might well be thinking that this is all very well, but it’s rather abstract and theoretical. What can the BERT model be used for, and how would we set about using it? To the first question, we need just say here ‘a wide variety of problems in NLP’, since BERT captures and expresses in its output representations so much of the context that matters in language processing. Examples include such classic problems as text summarization (of both extractive and abstractive kinds), classification tasks such as sentiment analysis, and translation. In terms of how BERT is used, it is important to note that it acts not on raw words but rather on text tokenized into WordPieces. And typically, the pre-trained BERT models are used as a starting point, with fine tuning then being performed in a subsequent training stage against input data relevant to the specific task and domain at hand. Concluding remarks The advent of BERT represents a shift in the tectonic plates of natural language processing. Using a Transformer-based architecture, the BERT model captures enough of the nuance of language to allow hitherto tough NLP problems to be tackled successfully. This opens up new digital vistas, and promises – dare one say it – to transform the nature of our relationship, through language, with computers. Moreover, approaches to NLP based on BERT and its kin offer hope that it will indeed be possible to meet the challenge posed by the sheer quantity of text held globally in digital form. Further reading Attention Is All You Need, by Ashish Vaswani, Noam Shazeer, and Niki Parmar, available at https://papers.nips.cc/paper/7181-attention-is-all-you-need.pdf BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding, by Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova, available at . https://arxiv.org/pdf/1810.04805.pdf Text Summarization with pre-trained Encoders by Yang Liu and Mirella Lapata, available at https://arxiv.org/pdf/1908.08345.pdf Buy the book here- http://packt.live/2Mg6cWt

PACKATIVE

packative.com

-- employees

Since n.d.

COMPANY RANKING

PACKATIVE

EVERGREEN INDEX #8027

Representing this company? Click here to claim and customize this page!

Packative WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

PACKATIVE

packative.com

-- employees

Since n.d.

COMPANY RANKING

PACKATIVE

EVERGREEN INDEX #8027

RELATED COMPANIESRANK

STORIES ABOUT PACKATIVE

Representing this company? Click here to claim and customize this page!

Packative WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!