Just another WordPress site
https://theawesomer.com/photos/2023/04/cruise_ship_time_lapse_t.jpg
MK Timelapse GmbH recorded the entire construction process of the AIDAnova, an 1105-foot-long cruise ship that carries 6600 passengers. The footage from Germany’s Meyer Neptun and Finland’s Meyer Turku shipyards starts out with massive engines being built and takes us through the fascinating modular assembly process.
The Awesomer
http://img.youtube.com/vi/tZ99AEyHKm4/0.jpgThere’s a common myth or misconception that Laravel uses Tailwind by default. You still can use Bootstrap, let me show you how.Laravel News Links
https://static1.makeuseofimages.com/wordpress/wp-content/uploads/2023/04/python-logo-with-scribbled-python-functions-3.jpg
As a programmer, you will often find yourself performing an action or task repeatedly. This can be tedious and time-consuming, especially when working with a large or complex code base. Automating them with functions is a more effective approach to performing such tasks. Functions allow you to write the code logic once and use it anywhere in your program.
In Python, a function is a block of code used to perform a specific task. You only need to write a function once, but you can use it multiple times in your code. A function can take in arguments as input and return output values. This simple program shows a function that calculates the sum of three numbers:
def calculate_sum(a, b, c):
return a+b+c
print(calculate_sum(1,2,3))
print(calculate_sum(1000, 300,44))
print(calculate_sum(12, 4,78))
In the program above, the function returns the sum of three arguments. When the function is called multiple times, it returns a different output for each case. A useful application for this function will be a calculator app.
Python has many built-in functions available for developers to use. However, these built-in functions are not always enough to meet the demands of most projects. To meet custom demands, you have to define your custom functions. Defining custom functions is common practice in programming.
In Python, you can define a custom function by using the def keyword followed by the name of your function with parenthesis in front of it. Here is an example:
def function_name()
You should take note of these rules when assigning a function name in Python:
After defining the function, you must write the logic to perform your desired task. For example, this function calculates the area of a triangle:
def calculate_triangle_area(base, height):
area = (base * height)/2
return area
print(calculate_triangle_area(12, 3))
The function above defines two parameters: base and height, divides their product by two, and returns the result as the output. You can write whatever logic you want your function to perform.
In previous examples, the functions have taken arguments to perform actions. The arguments in these examples are known as required or positional arguments. In Python, your arguments can be either of the following:
Positional arguments need to be passed in the correct order of definition. For example, if you define a function with parameters a, b, and c, you must pass in values for these parameters accordingly when you call them. Let us examine a previous example:
def calculate_sum(a, b, c):
return a+b+c
print(calculate_sum(1,2,3))
print(calculate_sum(1000, 300,44))
print(calculate_sum(12, 4,78))
In the above program, the calculate_sum() function takes three arguments whenever we call it. Each argument represents a corresponding parameter. In the first function call, numbers 1, 2, and 3 represent a, b, and c accordingly.
A parameter is declared in a function’s definition, while an argument is the value passed when you call the function This value is a representation of its corresponding parameter.
Positional arguments are compulsory. If you don’t add them, you will get a TypeError. The following example demonstrates this:
def calculate_sum(a, b, c):
return a+b+c
print(calculate_sum(1,2))
When you run the above program on your machine, you will get an error similar to the one in the image below:
Keyword arguments do not necessarily need to be passed whenever you call a function. They are optional arguments and don’t need to follow a specific order. Python lets us use *args and **kwargs to specify keyword arguments.
Apart from using *args and **kwargs, it is also possible to specify default values for your arguments. Doing this will not get an error if you forget to add a value when calling the function. This example gives an illustration:
def calculate_sum(a, b, c=3):
return a+b+c
print(calculate_sum(1,2))
In the above program, when calculate_sum() is called, there is no argument for c; this will not affect the program because c already has a default value. You can specify default values for as many arguments as you want but ensure you do this wisely.
Functions are useful for organizing your code, making it more readable and efficient. With functions, you can break your code into smaller, reusable chunks that are easier to understand and maintain. Additionally, if you need to make changes to your code, you only need to modify the necessary function rather than the entire code base.
MakeUseOf
https://cdn.hibit.dev/images/social/2023/preview/laravel_pagination.png
Laravel is a powerful PHP framework that has gained popularity due to its simplicity and flexibility. One of the features that make it stand out is pagination. Pagination is a technique used to break large datasets into smaller, more manageable pieces, allowing users to navigate through them with ease. By default, Laravel provides a pagination system that works well for most use cases. However, sometimes you may need to customize it to meet specific requirements. In this post, we will explore how to customize pagination in Laravel.
Laravel utilizes Composer to manage its dependencies. Take a look on how to install Composer on your computer. With composer on your machine we can install Laravel by running the following command in the terminal:
composer create-project --prefer-dist laravel/laravel hibit-pagination
This will install the latest version of Laravel and create a new project named hibit-pagination.
Before we can customize our pagination views, we need to generate them using artisan command:
php artisan vendor:publish --tag=laravel-pagination
This command will copy Laravel’s pagination views to the resources directory in our application:
We need to modify the configuration to choose from the available options for the paginator. To do this, we need to open the app/Providers/AppServiceProvider.php file and specify in boot method the desired option.
Once the paginator is selected, we can customize the blade view to match our application’s design. We can modify the resources/views/vendor/pagination/*.blade.php file to change the look and feel of our pagination links.
Customizing the blade and pagination styling in Laravel is a straightforward process that allows you to match the pagination links to your application’s design. By generating the pagination views, customizing the blade views, and customizing the pagination links, you can create pagination links that are unique to your application.
Laravel News Links
https://media.notthebee.com/articles/6439bc2758bc86439bc2758bc9.jpg
All of the homeschool parents I know rave about Khan Academy, particularly parents that could use some brushing up on their math and science skills.
Not the Bee
https://media.babylonbee.com/articles/643a975984506643a975984507.jpg
PEPPATOWN – Peppa Pig’s family vacation took an unexpected turn for the worse after Jesus of Nazareth healed a nearby demoniac.
“Mommy Pig, why is Auntie Pig screaming and running into the sea?” asked Peppa Pig. “Oh wow, George Pig! How did you learn to spin your head all the way around like that?”
According to eyewitnesses, the Pig family had been enjoying a relaxing day building sandcastles before suddenly rushing to drown themselves in the sea. “I asked Peppa to please hand me the shovel, and then she shouted ‘All hail Beelzebub!’ and dashed into the water,” said Rebecca Rabbit, sobbing. “What – what just happened?”
Citizens of the nearby village were reportedly furious that Jesus allowed the demons to go into the pigs. “Ugh, there went my kids’ entertainment,” said local man Abiah, son of Phineas. “Do you know how hard it is to get anything done with fourteen kids? They had all been happily watching those pigs play on the beach, and this Jesus guy had to ruin it by healing the town demoniac. Jesus has to go.”
At publishing time, the villagers had asked Jesus on his way out to send a few demons to chase away this explorer named Dora.
A Babylon Bee subscriber contributed to this report.
If you want to pitch your own headline ideas to our staff, click here to check out all of our membership options!
In this instructional video, Chinese soldiers are trained how to shout the wrong pronouns at American forces:
Subscribe to our YouTube channel for more tactical instruction
Babylon Bee
https://s.w.org/images/core/emoji/14.0.0/72×72/1f680.png
Boolean indexing in Pandas filters DataFrame rows using conditions. Example: df[df['column'] > 5] returns rows where 'column' values exceed 5. Efficiently manage and manipulate data with this method.
Here’s an easy example:
import pandas as pd
# Create a sample DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie', 'David'],
'Age': [25, 30, 35, 40],
'City': ['New York', 'San Francisco', 'Los Angeles', 'Seattle']}
df = pd.DataFrame(data)
# Perform boolean indexing to filter rows with age greater than 30
age_filter = df['Age'] > 30
filtered_df = df[age_filter]
# Display the filtered DataFrame
print(filtered_df)
This code creates a DataFrame with data for four people, then uses boolean indexing to filter out the rows with an age greater than 30. The filtered DataFrame is then printed.
Let’s dive slowly into Boolean Indexing in Pandas: 
Boolean indexing is a powerful feature in pandas that allows filtering and selecting data from DataFrames using a boolean vector. It’s particularly effective when applying complex filtering rules to large datasets 
.
To use boolean indexing, a DataFrame, along with a boolean index that matches the DataFrame’s index or columns, must be present.
To start, there are different ways to apply boolean indexing in pandas. One can access a DataFrame with a boolean index, apply a boolean mask, or filter data based on column or index values 
.
For instance, boolean indexing can filter entries in a dataset with specific criteria, such as data points above or below a certain threshold or specific ranges 
.
Working with boolean indexes is pretty straightforward. First, create a condition based on which data will be selected. This condition will generate a boolean array, which will then be used in conjunction with the pandas DataFrame to select only the desired data 
.
Here’s a table with examples of boolean indexing in pandas:
| Example | Description |
|---|---|
df[df['column'] > 10] |
Select only rows where 'column' has a value greater than 10. |
df[(df['column1'] == 'A') & (df['column2'] > 5)] |
Select rows where 'column1' is equal to 'A' and 'column2' has a value greater than 5. |
df[~(df['column'] == 'B')] |
Select rows where 'column' is not equal to 'B'. |
Boolean indexing in Pandas is a technique used to filter data based on actual values in the DataFrame, rather than row/column labels or integer locations. This allows for a more intuitive and efficient way to select subsets of data based on specific conditions. 
Let’s dive into the steps on how boolean indexing works in Pandas:
Before applying boolean indexing, you first need to create a boolean array. This array contains True and False values corresponding to whether a specific condition is met in the DataFrame. 
Consider the following example:
import pandas as pd
data = {'A': [1, 2, 3, 4],
'B': [5, 6, 7, 8]}
df = pd.DataFrame(data)
bool_array = df['A'] > 2
In this example, we create a boolean array by checking which elements in column 'A' are greater than 2. The resulting boolean array would be:
[False, False, True, True]
Once you have a boolean array, you can use it to filter the DataFrame based on the conditions you set. 
To do so, simply pass the boolean array as an index to the DataFrame.
Let’s apply the boolean array we created in the previous step:
filtered_df = df[bool_array]
This will produce a new DataFrame containing only the rows where the condition was met, in this case, the row that had values greater than 2:
A B
2 3 7
3 4 8
To provide more examples, let’s consider the following table:
| Boolean Condition | DataFrame[boolean_array] |
|---|---|
df['A'] >= 3 |
A B 2 3 7 3 4 8 |
df['B'] < 8 |
A B 0 1 5 1 2 6 2 3 7 |
(df['A'] == 1) | (df['B'] == 8) |
A B 0 1 5 3 4 8 |
(df['A'] != 1) & (df['B'] != 7) |
A B 1 2 6 3 4 8 |
Boolean indexing is also a powerful technique to filter data in Pandas DataFrames based on the actual values of the data, rather than row or column labels 
. In this section, you’ll learn how to harness the power of boolean indexing to filter your data efficiently and effectively.
To select rows based on a condition, you can create a boolean mask by applying a logical condition to a column or dataframe. Then, use this mask to index your DataFrame and extract the rows that meet your condition 
. For example:
import pandas as pd
data = {'A': [1, 2, 3, 4], 'B': [5, 6, 7, 8]}
df = pd.DataFrame(data)
mask = df['A'] > 2
filtered_data = df[mask]
In this example, the mask is a boolean Series with True values for rows with A > 2, and filtered_data is the filtered DataFrame containing only the rows that meet the condition.
For more complex filtering, you can combine multiple conditions using logical operators like & (AND), | (OR), and ~ (NOT). Just remember to use parentheses to separate your conditions:
Example:
mask2 = (df['A'] > 2) & (df['B'] < 8) filtered_data2 = df[mask2]
This filters the data for rows where both A > 2 and B < 8.
For even more complex filtering conditions, you can use the query method. This method allows you to write your conditions using column names, making it more readable and intuitive:
Example:
filtered_data3 = df.query('A > 2 and B < 8')
This achieves the same result as the masked2 example, but with a more readable syntax.
Here is a table summarizing the examples of boolean indexing with multiple conditions in Pandas:
| Example | Description |
|---|---|
df[(df['A'] > 2) & (df['B'] < 8)] |
Rows where A > 2 and B < 8 |
df[(df['A'] > 2) | (df['B'] < 8)] |
Rows where A > 2 or B < 8 |
df[~(df['A'] > 2)] |
Rows where A is not > 2 |
df.query('A > 2 and B < 8') |
Rows where A > 2 and B < 8, using query method |
With these techniques at your disposal, you’ll be able to use boolean indexing effectively to filter your Pandas DataFrames, whether you’re working with simple or complex conditions 
.
Boolean indexing is also great to modify data within a DataFrame or Series by specifying conditions that return a boolean array. These boolean arrays are then used to index the original DataFrame or Series, making it easy to modify selected rows or columns based on specific criteria.
In essence, it allows you to manipulate and clean data according to various conditions. It’s perfect for tasks like replacing missing or erroneous values, transforming data, or selecting specific data based on the criteria you set. This process is efficient and versatile, allowing for greater control when working with large datasets.
Now, let’s take a look at some examples of Boolean indexing in pandas to get a better understanding of how it works. The table below demonstrates various ways of modifying data using Boolean indexing:
| Operation | Example |
|---|---|
| Selecting rows that fulfill a condition | df[df['column_name'] > value] |
| Modifying values based on a condition | df.loc[df['column_name'] > value, 'column_name'] = new_ |
| Replacing values based on a condition | df['column_name'].where(df['column_name'] > value, alternative_value) |
| Performing calculation on values meeting a condition | df['column_name'][df['column_name'] > value] *= multiplier |
These examples showcase some basic boolean indexing operations in pandas, but it’s worth noting that more complex operations can be achieved using boolean indexing too. The key takeaway is that this powerful technique can quickly and efficiently modify your data, making your data processing tasks simpler and more effective.
So, next time you’re working with data in pandas, don’t forget to employ this nifty technique to make your data wrangling tasks more manageable and efficient. Happy data cleaning! 
Boolean indexing in Pandas has a wide range of advanced applications, allowing users to harness its power in complex scenarios. In this section, we will dive into a few of these applications, exploring their usefulness and demonstrating practical examples.
Combining indexers like iloc and loc with boolean indexing enhances the ability to select specific data subsets. Utilizing indexers in conjunction with boolean indexing allows you to specify both rows and columns, maintaining that sweet balance of performance and flexibility.
Dealing with missing data can be quite challenging. However, boolean indexing in Pandas comes to the rescue.
With boolean indexing, users can quickly filter out missing data by applying boolean masks. This makes data cleaning and preprocessing a breeze. No more headaches navigating through messy data!
MultiIndex, also known as a hierarchical index, adds another layer of depth to boolean indexing. By incorporating boolean indexing with MultiIndex DataFrames, you can access and manipulate data across multiple levels, enhancing your data exploration capabilities.
Here’s an example demonstrating the use of a MultiIndex in combination with boolean indexing in Pandas:
import pandas as pd
# Create a sample DataFrame with MultiIndex
index = pd.MultiIndex.from_tuples([('A', 1), ('A', 2), ('B', 1), ('B', 2)],
names=['Category', 'Subcategory'])
data = {'Value': [10, 15, 20, 25]}
df = pd.DataFrame(data, index=index)
# Perform boolean indexing to filter rows where 'Category' is 'A' and 'Value' is greater than 12
category_filter = df.index.get_level_values('Category') == 'A'
value_filter = df['Value'] > 12
filtered_df = df[category_filter & value_filter]
# Display the filtered DataFrame
print(filtered_df)
This code creates a DataFrame with a MultiIndex consisting of two levels: 'Category' and 'Subcategory'. Then, it uses boolean indexing to filter the rows where the 'Category' is 'A' and the 'Value' column is greater than 12. The filtered DataFrame is then printed.
The output of the provided code is:
Value Category Subcategory A 2 15
The filtered DataFrame contains only one row where the 'Category' is 'A', the 'Subcategory' is 2, and the 'Value' is 15, as this row meets both conditions specified in the boolean indexing.
Talk about leveling up your data analysis game! 
Time series data often requires efficient filtering and slicing. With boolean indexing applied to DateTime data, users can effortlessly filter their data based on specific date ranges, time periods, or even individual timestamps. 
You’ll never lose track of time with this powerful feature! 
Below is a table showcasing a few examples of boolean indexing in action:
| Scenario | Example Code |
|---|---|
| Filtering rows where column A is greater than 5 | data[data['A'] > 5] |
| Selecting rows where column B is equal to ‘x’ | data[data['B'] == 'x'] |
| Combining multiple conditions with logical AND | data[(data['A'] > 5) & (data['B'] == 'x')] |
| Filtering rows with missing data in column C | data[data['C'].notnull()] |
| Selecting data within a specific date range | data[(data['DateTime'] >= '2023-01-01') & (data['DateTime'] <= '2023-12-31')] |
Now you have a better understanding of advanced applications with boolean indexing in Pandas! Happy data wrangling!
In Pandas, Boolean indexing is a powerful way to filter and manipulate data using logical conditions 
. The “OR” operator, denoted by the symbol “|“, allows users to select rows that satisfy at least one of the specified conditions . In this section, let’s explore how the “OR” operator works with Boolean indexing in details, along with some examples .
With Pandas, users can combine multiple logical conditions using the “OR” operator by simply providing them with a “|“. This can be especially useful when working on complex data filtering tasks . Normally, the conditions are enclosed in parentheses to maintain order and group them correctly. Just remember to use the proper Boolean operator carefully! 
For a better understanding, let’s take a look at the following example on how the “OR” operator works with Boolean indexing in Pandas:
import pandas as pd
# Sample DataFrame
data = {'A': [1, 2, 3, 4, 5],
'B': [6, 7, 8, 9, 10]}
df = pd.DataFrame(data)
# Boolean indexing using "OR" operator
result = df[(df['A'] > 3) | (df['B'] <= 7)]
In this example, we have a DataFrame with two columns ‘A’ and ‘B’, and the goal is to filter rows where the value of ‘A’ is greater than 3 or the value of ‘B’ is less than or equal to 7. The resulting DataFrame will include rows that meet either condition 
.
| Column A | Column B | Condition |
|---|---|---|
| 1 | 6 | True |
| 2 | 7 | True |
| 3 | 8 | False |
| 4 | 9 | True |
| 5 | 10 | True |
Pandas boolean indexing is a powerful tool used for selecting subsets of data based on the actual values of the data in a DataFrame, which can make filtering data more intuitive . In this section, we’ll focus on the “NOT” operation and its usage in pandas boolean indexing.
The “NOT” operation is primarily used to reverse the selection made by the given condition, meaning if the condition is initially true, it will turn false, and vice versa. In pandas, the “not” operation can be performed using the tilde operator (~) 
. It can be particularly helpful when filtering the data that does not meet specific criteria.
Let’s consider some examples to understand better how “NOT” operation works in pandas boolean indexing:
| Example | Description |
|---|---|
~df['column_name'].isnull() |
Selects rows where ‘column_name‘ is NOT null |
~(df['column_name'] > 100) |
Selects rows where ‘column_name‘ is NOT greater than 100 |
~df['column_name'].str.contains('value') |
Selects rows where ‘column_name‘ does NOT contain the string 'value' |
In these examples, the tilde operator (~) is utilized to perform the “NOT” operation, which helps to refine the selection criteria to better suit our needs. We can also combine the “NOT” operation with other boolean indexing operations like “AND” (&) and “OR” (|) to create more complex filtering conditions .
Remember, when working with pandas boolean indexing, it’s essential to use parentheses to group conditions properly, as it ensures the correct precedence of operations and avoids ambiguity when combining them 
.
Boolean indexing in pandas provides an efficient and easy way to filter your data based on specific conditions, and mastering the different operations, such as “NOT”, allows you to craft precise and powerful selections in your DataFrames .
Pandas Boolean indexing is a powerful technique that allows you to select subsets of data in a DataFrame based on actual values rather than row or column labels 
. This technique is perfect for filtering data based on specific conditions .
When using Boolean indexing, you can apply logical conditions using comparison operators or combination operators like & (and) and | (or) 
. Keep in mind that when applying multiple conditions, you must wrap each condition in parentheses for proper evaluation 
.
Let’s go through a few examples to better understand how Boolean indexing with lists works!
| Example | Description |
|---|---|
df[df['col1'].isin(['a', 'b'])] |
Select rows where ‘col1’ is either ‘a’ or ‘b’ |
df[(df['col1'] == 'a') | (df['col1'] == 'b')] |
Select rows where ‘col1’ is either ‘a’ or ‘b’, alternate method |
df[(df['col1'] == 'a') & (df['col2'] > 10)] |
Select rows where ‘col1’ is ‘a’ and ‘col2’ is greater than 10 |
df[~df['col1'].isin(['a', 'b'])] |
Select rows where ‘col1’ is neither ‘a’ nor ‘b’, using the ‘not in’ condition |
Remember, when working with Pandas Boolean indexing, don’t forget to import the pandas library, use proper syntax, and keep practicing 
! This way, you’ll be a Boolean indexing pro in no time !
Boolean indexing in pandas refers to the process of selecting subsets of data based on their actual values rather than row or column labels or integer locations. It utilizes a boolean vector as a filter for the data in a DataFrame 
. This powerful technique enables users to easily access specific data pieces based on conditions while performing data analysis tasks .
In pandas, boolean indexing commonly employs logical operators such as AND (&), OR (|), and NOT (~) to create a boolean mask which can be used to filter the DataFrame. The process usually involves creating these logical expressions by applying conditions to one or more columns, and then applying the boolean mask to the DataFrame to achieve the desired subset .
Here’s a table showing some examples of boolean indexing with pandas:
| Example | Description |
|---|---|
df[df['A'] > 2] |
Filter DataFrame where values in column A are greater than 2 . |
df[(df['A'] > 2) & (df['B'] < 5)] |
Select rows where column A values are greater than 2, and column B values are less than 5 . |
df[df['C'].isin([1, 3, 5])] |
Filter DataFrame where column C contains any of the values 1, 3, or 5  . |
df[~df['D'].str.contains('abc')] |
Select rows where column D doesn’t contain the substring ‘abc’  . |
Boolean indexing is an essential tool for data manipulation in pandas, offering a versatile solution to filter and identify specific elements within the data. Harnessing the power of boolean indexing can greatly improve the efficiency of data analysis tasks, making it a valuable skill to master for users working with pandas data structures .
In Pandas, Boolean indexing is a powerful feature that allows users to filter data based on the actual values in a DataFrame , instead of relying on their row or column labels. This technique uses a Boolean vector (True or False values) to filter out and select specific data points in a DataFrame . Let’s dive into how it works!
Using logical operators such as AND (&), OR (|), and NOT (~), Pandas makes it easy to combine multiple conditions while filtering data. Below is a table showcasing some examples of how to use Boolean indexing in Pandas to set values with different conditions:
| Condition | Code Example |
|---|---|
| Setting values based on a single condition | df.loc[df['column_name'] > 10, 'new_column'] = 'Greater than 10' |
| Setting values based on multiple conditions (AND) | df.loc[(df['column1'] == 'A') & (df['column2'] == 'B'), 'new_column'] = 'Both conditions met' |
| Setting values based on multiple conditions (OR) | df.loc[(df['column1'] == 'A') | (df['column2'] == 'B'), 'new_column'] = 'One condition met' |
| Setting values based on NOT conditions | df.loc[ ~(df['column_name'] < 10), 'new_column'] = 'Not less than 10' |
When working with Pandas, Boolean indexing can tremendously simplify the process of filtering and modifying datasets for specific tasks . Remember that the possibilities are virtually endless, and you can always combine conditional statements to manipulate your datasets in numerous ways!
Sometimes when working with Pandas, you may encounter issues with Boolean indexing. There are a few common scenarios that can lead to Boolean indexing not functioning as expected. Let’s go through these cases and their possible solutions.
One common issue arises when using Boolean Series as an indexer. This may lead to an IndexingError: Unalignable boolean Series provided as indexer error. This usually occurs when the Boolean mask cannot be aligned on the index, which is used by default when trying to filter a DataFrame (source).
To overcome this problem, ensure that your Boolean Series index aligns with your DataFrame index. You can use the `.loc` method with the same index as the DataFrame to make sure the Series is alignable:
df[df.notnull().any(axis=0).loc[df.columns]]
Another issue that may arise is confusion with logical operators during the Boolean indexing process. In Pandas, logical operators for Boolean indexing are different from standard Python logical operators. You should use & for logical AND, | for logical OR, and ~ for logical NOT (source).
For example, to filter rows based on two conditions:
df[(df['col1'] == x) & (df['col2'] == y)]
Here is a table with some examples of Boolean indexing in Pandas:
| Condition | Code Example |
|---|---|
| Rows with values in ‘col1’ equal to x | df[df['col1'] == x] |
| Rows with values in ‘col1’ less than x and ‘col2’ greater than y | df[(df['col1'] < x) & (df['col2'] > y)] |
| Rows where ‘col1’ is not equal to x | df[~(df['col1'] == x)] |
By understanding these potential pitfalls, you can ensure smoother Boolean indexing in your Pandas projects. Good luck, and happy data wrangling!
Be on the Right Side of Change
https://theawesomer.com/photos/2023/04/matterhorn_drone_t.jpg
We’ve seen what it’s like at the top of the Matterhorn for a wingsuit flyer. Now, head back to the peak of Hornli Ridge for an epic drone flight courtesy of pilot Joshua Turner. He captured the incredible footage of the iconic mountain summit using an Iflight Chimera 7 drone, a DJI Air Unit rig, a GoPro Hero 10 Black camera.
The Awesomer
Discover new & useful Laravel packages. A place where you can find any Laravel package that you may need for your next project.Laravel News Links
https://cdn.arstechnica.net/wp-content/uploads/2023/04/dolly_hero-760×380.jpg
Databricks
On Wednesday, Databricks released Dolly 2.0, reportedly the first open source, instruction-following large language model (LLM) for commercial use that’s been fine-tuned on a human-generated data set. It could serve as a compelling starting point for homebrew ChatGPT competitors.
Databricks is an American enterprise software company founded in 2013 by the creators of Apache Spark. They provide a web-based platform for working with Spark for big data and machine learning. By releasing Dolly, Databricks hopes to allow organizations to create and customize LLMs “without paying for API access or sharing data with third parties,” according to the Dolly launch blog post.
Dolly 2.0, its new 12-billion parameter model, is based on EleutherAI’s pythia model family and exclusively fine-tuned on training data (called “databricks-dolly-15k”) crowdsourced from Databricks employees. That calibration gives it abilities more in line with OpenAI’s ChatGPT, which is better at answering questions and engaging in dialogue as a chatbot than a raw LLM that has not been fine-tuned.
Dolly 1.0, released in March, faced limitations regarding commercial use due to the training data, which contained output from ChatGPT (thanks to Alpaca) and was subject to OpenAI’s terms of service. To address this issue, the team at Databricks sought to create a new data set that would allow commercial use.
To do so, Databricks crowdsourced 13,000 demonstrations of instruction-following behavior from more than 5,000 of its employees between March and April 2023. To incentivize participation, they set up a contest and outlined seven specific tasks for data generation, including open Q&A, closed Q&A, extracting and summarizing information from Wikipedia, brainstorming, classification, and creative writing.
The resulting numbers, along with Dolly’s model weights and training code, have been released fully open source under a Creative Commons license, enabling anyone to use, modify, or extend the data set for any purpose, including commercial applications.
In contrast, OpenAI’s ChatGPT is a proprietary model that requires users to pay for API access and adhere to specific terms of service, potentially limiting the flexibility and customization options for businesses and organizations. Meta’s LLaMA, a partially open source model (with restricted weights) that recently spawned a wave of derivatives after its weights leaked on BitTorrent, does not allow commercial use.
On Mastodon, AI researcher Simon Willison called Dolly 2.0 “a really big deal.” Willison often experiments with open source language models, including Dolly. “One of the most exciting things about Dolly 2.0 is the fine-tuning instruction set, which was hand-built by 5,000 Databricks employees and released under a CC license,” Willison wrote in a Mastodon toot.
If the enthusiastic reaction to Meta’s only partially open LLaMA model is any indication, Dolly 2.0 could potentially spark a new wave of open source language models that aren’t hampered by proprietary limitations or restrictions on commercial use. While the word is still out about Dolly’s actual performance ability, further refinements might allow running reasonably powerful LLMs on local consumer-class machines.
“Even if Dolly 2 isn’t good, I expect we’ll see a bunch of new projects using that training data soon,” Willison told Ars. “And some of those might produce something really useful.”
Currently, the Dolly weights are available at Hugging Face, and the databricks-dolly-15k data set can be found on GitHub.
Ars Technica – All content